Query processing

Distributed
Query Processing
8/10/2017 1Md. Golam Moazzam, Dept. of CSE, JU

OUTLINE
 What is Query ?
 What is Query Processor?
 Main Function of a Query Processor
 Main Problems of Query Processing
 Characteristics of Query Processor
 Main layers of Query Processing
 Query Decomposition
 Data Localization
 Global Query Optimization
 Distributed Execution

 What is Query ?
 A query is a statement requesting the retrieval of
information.
 The portion of a DML that involves information retrieval is
called a query language.
Distributed Query Processing

 What is Query Processor?
 In relational database technology, users perform the task of
data processing and data manipulation with the help of high-
level non-procedural language (e.g. SQL).
 This high-level query hides the low-level details from the
user about the physical organization of the data and presents
such an environment so that the user can handle the tasks of
even complex queries in an easy, concise and simple
fashion.
 The inner procedure of query-task is performed by a
DBMS module called a Query Processor. Hence the users
are relieved from query optimization which is a time-
consuming task that is actually performed by the query
processor.

 What is Query Processor?
 Understanding Query processing in distributed database
environments is very difficult instead of centralized
database, because there are many elements or parameters
involved that affect the overall performance of distributed
queries. Moreover, in distributed environment, the query
processor may have to access in many sites. Thus, query
response time may become very high.
 That is why, Query processing problem is divided into
several sub-problems/ steps which are easier to solve
individually.

 Main Function/Objective of a Query Processor
 Main function of a query processor is to transform a high-
level-query (also called calculus query) into an
equivalent lower-level query (also called algebraic
query).
 The conversion must be correct and efficient. The
conversion will be correct if low-level query has the
same semantics as the original query, i.e. if both queries
produce the same result.

 Main Problems of Query Processing
 Main problem of query processing is query optimization.
 It is a time consuming task, because many execution
strategies are involved to minimize (optimize) computer
recourse consumption.
 Total cost also affects query processing. Cost depends on
the time required for processing operations of the query at
various sites, utilization of various computer resources etc,
time needed for exchanging data between sites participating
in the execution of the query etc.
 Time and space required to process the query is also an
important factor for the performance of the query
processing.

 Important Characteristics of Query Processor
 Languages
 Types of Optimization
 Optimization Timing
 Statistics
 Decision Sites
 Exploitation of the Network Topology
 Exploitation of Replicated Fragments
 Use of Semi-join

Languages:
 Input language to the query processor is based on high-level
relational DBMS, i.e. input is in calculus query.
 On the other hand, output language is based on lower-level
relational DMBS, i.e. output is in algebraic query.
 The operations of the output language are implemented
directly in the computer system.
 Query processing must perform efficient mapping from the
input language to the output language.

Types of Optimization:
 Among all possible strategies for executing query, the one in
which less time and space are required is the best solution
for the optimization of query.
 A comparative study for all the strategies should perform
such that how much cost will be required for each solution.
That strategy should be chosen in which there will be less
cost. But keep in mind that choosing the low-cost strategy
may require much space. So care should be taken in this
case also.

Optimization Timing:
 The actual time required to optimize the execution of a
query is an important factor. If less time is required, then it
is the best solution for query processing.

Statistics:
 The effectiveness of query optimization relies on statistical
information of the database, i.e. how many fragments
query will be needed, which operation should be done first,
size and number of distinct values of each attribute of the
relation, histograms of the attributes for minimizing
probability error etc.

Decision Sites:
 In a distributed database, several sites may participate for
answering the query. Most systems use centralized decision
approach, in which a single site generates the strategy.
However, the decision process could be distributed among
various sites.
Exploitation of Network Topology:
 Distributed query processor uses computer network, so its
performance depends also on which topology it is using.
The cost function, speed, utilization of various network
resources are important factors for executing query
processor in a distributed environment.

Exploitation of Replicated Fragments:
 A distributed relation is usually divided into relation
fragments.
 Distributed queries expressed on global relations are
mapped into queries on physical fragments of relations by
translating relations into fragments. We call this process
localization because its main function is to localize the data
involved in the query.
 For higher reliability and better read performance, it is
useful to have fragments replicated at different sites.

Use of Semi-join operation:
 In distributed system, it is better to use semi-join operation
instead of join operation for minimizing data
communication.

 Layers of Query Processing
 Processing of Query in distributed DBMS instead of
centralized (Local) DBMS.
 Understanding Query processing in distributed database
environments is very difficult instead of centralized
database, because there are many elements involved.
 So, Query processing problem is divided into several sub-
problems/ steps which are easier to solve individually.
 A general layering scheme for describing distributed query
processing is given below:

 Main layers of Query Processing
Query processing involves 4 main layers:
• Query Decomposition
• Data Localization
• Global Query Optimization
• Distributed Execution

Query Decomposition
Calculus Query on Global Relations
Algebraic Query on Global Relations
Data Localization
Algebraic Query on Fragments
Global Optimization
Distributed Query Execution Plan
Distributed Execution
Global
Schema
Fragment
Schema
Allocation
Schema
Control Site
Local Sites
Fig. Generic Layering Scheme for Distributed Query Processing

 The input is a query on global data expressed in relational
calculus. This query is posed on global (distributed)
relations, meaning that data distribution is hidden.
 The first three layers map the input query into an optimized
distributed query execution plan. They perform the
functions of query decomposition, data localization, and
global query optimization.
 Query decomposition and data localization correspond to
query rewriting.
 The first three layers are performed by a central control site
and use schema information stored in the global directory.
 The fourth layer performs distributed query execution by
executing the plan and returns the answer to the query. It is
done by the local sites and the control site.

 Query Decomposition
 The first layer decomposes the calculus query into an
algebraic query on global relations. The information needed
for this transformation is found in the global conceptual
schema describing the global relations.
 Both input and output queries refer to global relations,
without knowledge of the distribution of data. Therefore,
query decomposition is the same for centralized and
distributed systems.
 Query decomposition can be viewed as four successive
steps:
 1) Normalization, 2) Analysis,
3) Elimination of redundancy, and 4) Rewriting.

 First, the calculus query is rewritten in a normalized form
that is suitable for subsequent manipulation. Normalization
of a query generally involves the manipulation of the query
quantifiers and of the query qualification by applying
logical operator priority.
 Second, the normalized query is analyzed semantically so
that incorrect queries are detected and rejected as early as
possible. Typically, they use some sort of graph that
captures the semantics of the query.

 Third, the correct query is simplified. One way to simplify a
query is to eliminate redundant predicates.
 Fourth, the calculus query is restructured as an algebraic
query. Several algebraic queries can be derived from the
same calculus query, and that some algebraic queries are
“better” than others. The quality of an algebraic query is
defined in terms of expected performance.

 Normalization
 The input query may be arbitrarily complex.
 It is the goal of normalization to transform the query to a
normalized form to facilitate further processing.
 With relational languages such as SQL, the most important
transformation is that of the query qualification (the
WHERE clause), which may be an arbitrarily complex,
quantifier-free predicate, preceded by all necessary
quantifiers ( or ).
 There are two possible normal forms for the predicate, one
giving precedence to the AND (^) and the other to the OR
(˅). The conjunctive normal form is a conjunction (^
predicate) of disjunctions (˅ predicates) as follows:
(p11 ˅ p12 ˅ . . . ˅ p1n) ^ . . . . ^ (pm1 ˅ pm2 ˅ . . . ˅ pmn)
where pi j is a simple predicate.
 

 Normalization
 A qualification in disjunctive normal form, on the other
hand, is as follows:
(p11 ^ p12 ^ . . . ^ p1n) ˅ . . . . ˅ (pm1 ^ pm2 ^ . . . ^ pmn)
 The transformation is straightforward using the well-known
equivalence rules for logical operations (^, ˅ and ¬):
1. p1 ^ p2 p2 ^ p1
2. p1 ˅ p2 p2 ˅ p1
3. p1 ^ (p2 ^ p3) (p1 ^ p2) ^ p3
4. p1 ˅ (p2 ˅ p3) (p1 ˅ p2) ˅ p3
5. p1 ^ (p2 ˅ p3) (p1 ^ p2) ˅ (p1 ^ p3)
6. p1 ˅ (p2 ^ p3) (p1 ˅ p2) ^ (p1 ˅ p3)
7. ¬ (p1 ^ p2) ¬ p1 ˅ ¬ p2
8. ¬ (p1 ˅ p2) ¬ p1 ^ ¬ p2
9. ¬ (¬ p) p










 Example: Let us consider the following query on the
engineering database that we have been referring to:
“Find the names of employees who have been working on
project P1 for 12 or 24 months”
Engineering Database:
EMP(ENO, ENAME, TITLE)
PROJ(PNO, PNAME, BUDGET).
SAL(TITLE, AMT)
ASG(ENO, PNO, RESP, DUR)
;SAL=Salary, AMT=Amount
; Employees assigned to projects
; RESP=Responsibility, DUR=Duration

The query expressed in SQL is
SELECT ENAME
FROM EMP, ASG
WHERE EMP.ENO = ASG.ENO
AND ASG.PNO = "P1"
AND DUR = 12 OR DUR = 24

The qualification in conjunctive normal form is
EMP.ENO = ASG.ENO ^ ASG.PNO = “P1” ^ (DUR = 12 ˅
DUR = 24)
The qualification in disjunctive normal form is
(EMP.ENO = ASG.ENO ^ ASG.PNO = “P1” ^ DUR = 12) ˅
(EMP.ENO = ASG.ENO ^ ASG.PNO = “P1” ^ DUR = 24)

 Analysis
 Query analysis enables rejection of normalized queries for
which further processing is either impossible or
unnecessary.
 The main reasons for rejection are that the query is type
incorrect or semantically incorrect.
 A query is type incorrect if any of its attribute or relation
names are not defined in the global schema, or if operations
are being applied to attributes of the wrong type.
 The technique used to detect type incorrect queries is similar
to type checking for programming languages.

 Analysis
Example: The following SQL query on the engineering
database is type incorrect for two reasons. First, attribute E# is
not declared in the schema. Second, the operation “>200” is
incompatible with the type string of ENAME.
SELECT E#
FROM EMP
WHERE ENAME > 200

 Analysis
 A query is semantically incorrect if its components do not
contribute in any way to the generation of the result.
 This is based on the representation of the query as a graph,
called a query graph or connection graph.
 In a query graph, one node indicates the result relation, and
any other node indicates an operand relation. An edge
between two nodes one of which does not correspond to the
result represents a join, whereas an edge whose destination
node is the result represents a project.
 An important subgraph of the query graph is the join graph,
in which only the joins are considered.

 Analysis
Example: Let us consider the following query:
“Find the names and responsibilities of programmers who have
been working on the CAD/CAM project for more than 3 years.”
The query expressed in SQL is
SELECT ENAME, RESP
FROM EMP, ASG, PROJ
AND ASG.PNO = PROJ.PNO
AND PNAME = "CAD/CAM"
AND DUR ≥ 36
AND TITLE = "Programmer“

 Analysis
Query Graph:
ASG
PROJ
EMP
RESULT
ASG.PNO = PROJ.PNO
EMP.ENO = ASG.ENO
TITLE=
“Programmer” PNAME = “CAD/CAM”ENAME
RESP
Fig.: Query Graph
DUR ≥ 36

 Analysis
Join Graph:
ASG
PROJ
EMP
ASG.PNO = PROJ.PNO
EMP.ENO = ASG.ENO
Fig.: Corresponding Join Graph

 Analysis
A query is semantically incorrect if its query graph is not
connected.
Example: Let us consider the following SQL query:
SELECT ENAME, RESP
FROM EMP, ASG, PROJ
AND PNAME = "CAD/CAM"
AND DUR _ 36
AND TITLE = "Programmer"

 Analysis
It’s query graph, shown below is disconnected, which tells us
that the query is semantically incorrect.
PNAME = “CAD/CAM”
ASG
PROJ
EMP
RESULT
EMP.ENO = ASG.ENO
TITLE = “Programmer”
ENAME
RESP
Fig.: Query Graph
DUR ≥ 36

 Elimination of Redundancy
 Simplify the query by eliminating redundancies, e.g.,
redundant predicates.
 Redundancies are often due to semantic integrity constraints
expressed in the query language.
 Transformation rules are used:

Example:
SELECT TITLE
FROM EMP
WHERE (NOT (TITLE = "Programmer")
AND (TITLE = "Programmer"
OR TITLE = "Elect. Eng.")
AND NOT (TITLE = "Elect. Eng."))
OR ENAME = "J. Doe"

Example:
Can be simplified using the previous rules to become
SELECT TITLE
FROM EMP
WHERE ENAME = "J. Doe“
The simplification proceeds as follows:
Let p1 be TITLE = “Programmer”,
p2 be TITLE = “Elect. Eng.”, and
p3 be ENAME = “J. Doe”.
The query qualification is:
(¬ p1 ^ (p1 ˅ p2) ^ ¬ p2) ˅ p3

The disjunctive normal form for this qualification is obtained by
applying rule 5 which yields:
(¬ p1 ^ ((p1 ^ ¬ p2) ˅ (p2 ^ ¬ p2))) ˅ p3
and then rule 3 yields:
(¬ p1 ^ p1 ^ ¬ p2) ˅ (¬ p1 ^ p2 ^ ¬ p2) ˅ p3
By applying rule 7, we obtain
(false ^ ¬ p2) ˅ (¬ p1 ^ false) ˅ p3
By applying the same rule, we get
(false ˅ false) ˅ p3
which is equivalent to p3 by rule 4.

 Rewriting
 The last step of query decomposition rewrites the query in
relational algebra.
 For the sake of clarity it is customary to represent the
relational algebra query graphically by an operator tree.
 An operator tree is a tree in which a leaf node is a relation
stored in the database, and a non-leaf node is an
intermediate relation produced by a relational algebra
operator. The sequence of operations is directed from the
leaves to the root, which represents the answer to the query.

 Rewriting
The transformation of a tuple relational calculus query into an
operator tree can easily be achieved as follows:
 First, a different leaf is created for each different tuple
variable (corresponding to a relation). In SQL, the leaves
are immediately available in the FROM clause.
 Second, the root node is created as a project operation
involving the result attributes. These are found in the
SELECT clause in SQL.
 Third, the qualification (SQL WHERE clause) is translated
into the appropriate sequence of relational operations
(select, join, union, etc.) going from the leaves to the root.
The sequence can be given directly by the order of
appearance of the predicates and operators.

 Rewriting
Example:
“Find the names of employees other than J. Doe who worked on
the CAD/CAM project for either one or two years” whose SQL
expression is:
SELECT ENAME
FROM PROJ, ASG, EMP
WHERE ASG.ENO = EMP.ENO
AND ASG.PNO = PROJ.PNO
AND ENAME != "J. Doe"
AND PROJ.PNAME = "CAD/CAM"
AND (DUR = 12 OR DUR = 24)

 Rewriting
Operator Tree:
ΠENAME
σPNAME=”CAD/CAM”
σDUR=12 ˅ DUR=24
σENAME≠”J. Doe”
PNO
ENO
PROJ ASG EMP
Fig: Operator tree
Project
Select
Join

 Localization of Distributed Data
 Output of the first layer is an algebraic query on distributed
relations which is input to the second layer.
 The main role of this layer is to localize the query’s data
using data distribution information.
 We know that relations are fragmented and stored in disjoint
subsets, called fragments where each fragment is stored at
different site.

 Localization of Distributed Data
 This layer determines which fragments are involved in
the query and transforms the distributed query into a
fragment query.
 A naive way to localize a distributed query is to generate a
query where each global relation is substituted by its
localization program. This can be viewed as replacing the
leaves of the operator tree of the distributed query with
subtrees corresponding to the localization programs. We call
the query obtained this way the localized query.

 Global Query Optimization
 The input to the third layer is a fragment algebraic query.
 The goal of this layer is to find an execution strategy for
the algebraic fragment query which is close to optimal.
 Query optimization consists of
i) Finding the best ordering of operations in the fragment
query,
ii) Finding the communication operations which minimize
a cost function.

 Global Query Optimization
 The cost function refers to computing resources such as
disk space, disk I/Os, buffer space, CPU cost,
communication cost, and so on.
 Query optimization is achieved through the semi-join
operator instead of join operators.

 Distributed Execution
 The last layer is performed by all the sites having
fragments involved in the query.
 Each subquery, called a local query, is executing at one
site. It is then optimized using the local schema of the
site.

Query processing

More Related Content

What's hot

Similar to Query processing

More from University of Potsdam

Recently uploaded

Query processing