ConQuer Efficient Management of Inconsistent Databases
ConQuer:Ef?cient Management of Inconsistent Databases
Ariel Fuxman,Elham Fazli,Ren′ee https://www.wendangku.net/doc/6018855137.html,ler?
{afuxman,elham,miller}@https://www.wendangku.net/doc/6018855137.html,
University of Toronto
ABSTRACT
Although integrity constraints have long been used to main-tain data consistency,there are situations in which they may not be enforced or satis?ed.In this paper,we present Con-Quer,a system for e?cient and scalable answering of SQL queries on databases that may violate a set of constraints. ConQuer permits users to postulate a set of key constraints together with their queries.The system rewrites the queries to retrieve all(and only)data that is consistent with re-spect to the constraints.The rewriting is into SQL,so the rewritten queries can be e?ciently optimized and executed by commercial database systems.
We study the overhead of resolving inconsistencies dy-namically(at query time).In particular,we present a set of performance experiments that compare the e?ciency of the rewriting strategies used by ConQuer.The experiments use queries taken from the TPC-H workload.We show that the overhead is not onerous,and the consistent query answers can often be computed within twice the time required to obtain the answers to the original(non-rewritten)query. 1.INTRODUCTION
Integrity constraints have long been used to maintain data consistency.Data design focuses on developing a set of constraints to ensure that every possible database re?ects a valid,consistent state of the world.However,integrity constraints may not be enforced or satis?ed for a number of reasons.In some environments,checking the consistency of constraints may be too expensive,particularly for workloads with high update rates.Hence,the database may become inconsistent with respect to the(unenforced)integrity con-straints.When data is integrated from multiple sources, each source may satisfy a constraint(for example a key con-straint),but the merged data may not(if the same key value exists in multiple sources).More generally,when data is ex-changed between independently designed sources with dif-ferent constraints,the exchanged data may not satisfy the ?Supported in part by NSERC and CITO awards. Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for pro?t or commercial advantage,and that copies bear this notice and the full citation on the?rst page.To copy otherwise,to republish,to post on servers or to redistribute to lists,requires prior speci?c permission and/or a fee.
SIGMOD2005June14-16,2005,Baltimore,Maryland,USA. Copyright2005ACM1-59593-060-4/05/06$5.00.constraints of the destination schema.
One strategy for managing inconsistent databases is data cleaning[9].Data cleaning techniques seek to identify and correct errors in the data and can be used to restore the database to a consistent state.Data cleaning,when appli-cable,may be very successful.However,these techniques are semi-automatic at best,and they can infeasible or unaf-fordable for some applications.Furthermore,committing to a single cleaning strategy may not be appropriate for some environments.A user may wish to experiment with di?er-ent cleaning strategies,or may desire to retain all data,even inconsistent data,for tasks such as lineage tracing.Finally, data cleaning is only applicable to data that contains errors. However,the violation of a constraint may also indicate that the data contains exceptions,that is,clean data that simply does not satisfy a constraint.
In this work,we take an approach that is applicable to databases with both errors and exceptions.We propose a system,ConQuer,for managing inconsistent data.1In Con-Quer,a user may postulate a set of integrity constraints, possibly at query time,and the system retrieves all(and only)the query answers that are consistent with respect to the constraints.In order to do this,ConQuer rewrites the query into another SQL query that retrieves the consistent answers.We illustrate the semantics of consistent query an-swering and ConQuer’s rewriting strategy with an example, and provide precise de?nitions in Section2.2
Example 1.Consider the database of Figure1,which contains information about customers and their account bal-ances.Assume that a user speci?es that the key of the customer relation should be custkey.Note that the database violates this key constraint,perhaps because its data has been integrated from many operational sources.Consider a query that retrieves information about customers whose account balance is over1000.
q1:select custkey
from customer
where acctbal>1000
If we execute this query over the instance of Figure1,we obtain{c1,c2,c3,c3}.This cannot be considered a“consis-tent”answer for the following reasons.First,it may be the 1ConQuer stands for Consistent Querying.
2In the examples throughout the paper,we use queries mo-tivated by those in the TPC-H workload,but simpli?ed to illustrate speci?c points.However,in the experiments of Section6,we use actual TPC-H queries.
custkey acctbal
t1c12000
t2c1100
t3c22500
t4c32200
t5c32500
Figure1:Inconsistent instance of the customer rela-tion
case that customer c1has an account balance below1000 (tuple t2).However,c1is included in the answer because it appears in another tuple(t1)which does satisfy the query. Second,customer c3appears in the answer twice.Since we consider custkey to be the key of the relation,we do not expect to have repeated values in the answer.
In this case,we would expect{c2,c3}to be the“consis-tent”answer for query q1.The reason is that c2appears in a single tuple of the database,which satis?es the query and does not violate the key constraint.Even though c3appears in two tuples(which therefore violate the key constraint), both tuples satisfy the query.
ConQuer rewrites queries in order to obtain their consis-tent answers.For q1,it would produce the following query rewriting:
select distinct custkey
from customer c
where acctbal>1000
and not exists(select*
from customer c’
where c’.custkey=c.custkey
and c’.acctbal≤1000) The rewritten query has two di?erences with respect to q1. First,it uses the distinct keyword to ensure that each con-sistent answer is returned the right number of times.In this case,this ensures that c3appears exactly once in the answer. Second,it has a nested subquery related by not exists.The purpose of this subquery is to?lter out those key values that satisfy q1in some tuples,but violate it in others.In our example,this subquery?lters c1from the answer because it appears in tuple t2with an account balance below1000.
We will use a common de?nition of consistent query an-swer based on the notion of repair[2].For keys,a repair is a subset of the inconsistent database containing exactly one tuple per key value.A repair is one possible“cleaned”version of the database.A query answer is then consistent if it is an answer to the query in every repair.In con-trast,for monotone queries(queries without negation such as the query of Example1),the original query executed on an inconsistent database returns a set of possible answers.
A possible answer is an answer to the query in at least one repair.In the next section,we will give a precise de?nition of consistent answers for arbitrary queries and constraints (not just keys).
In the absence of user input to decide between tuples that violate a constraint,ConQuer provides the option of retain-ing all tuples,rather than forcing the user to remove(or ig-nore)the inconsistent data.Furthemore,our approach is or-thogonal to any cleaning that may be done on the database.In particular,ConQuer can be used interactively by users to understand where the data is potentially inconsistent.For example,if we take the di?erence between the result of the original and rewritten queries of Example1,we can detect that customer c1satis?es the query but is not a consistent answer.This may indicate that its data should be cleaned. As another example,a user may not be too concerned if there are multiple tuples for a customer that di?er on ad-dress(something that can be corrected with a specialized data cleaning tool for addresses like Trillium3),provided that other important information,such as the market seg-ment,is consistent.
Summary of Results.The main contributions of our work are the following:
?We present algorithms for rewriting SQL queries into
SQL queries that return only consistent answers.Our
approach is fully declarative,requiring no procedural
pre-or post-processing.This enables us to apply our
techniques to much larger databases than any of the
existing consistent query answering systems.
?We consider not only Select-Project-Join(SPJ)queries,
but also SQL’s bag semantics and queries with aggre-
gation.Our rewritings for these features are novel con-
tributions,and are needed to enable practical use in
analysis queries over an integrated and potentially in-
consistent data warehouse.
?We present a rewriting that works over the unchanged
(inconsistent)database and a second rewriting that
makes use of annotations attached to tuples indicat-
ing whether the tuple is known to be consistent.Such
annotations are appropriate for high performance envi-
ronments where the inconsistent data represents valu-
able data that cannot be removed.We show how such
annotations can be exploited using query optimiza-
tions speci?c to the semantics of consistent query an-
swering.These optimizations are highly e?ective and
would not be found by a standard optimizer.
?We present a performance study using the data and
queries of the TPC-H decision support benchmark.
Our study highlights the overhead of dynamically(at
query time)resolving inconsistencies when o?-line clean-ing is not possible(or not appropriate for the applica-
tion).We consider di?erent degrees of inconsistency
(we experiment with databases in which up to50%of
the database may be inconsistent)and database sizes
to understand the applicability of our approach.
In the next section,we precisely de?ne consistent query answering.Our query rewriting strategy for queries with-out aggregation is presented in Section3.In Section4,we consider queries with aggregation.In Section5,we present an optimization of the rewritings that exploits precomputed information about constraint violations.In Section6,we present a performance study which uses queries from the TPC-H decision support benchmark.In Section7,we con-sider related work in the area of consistent query answering. We close the discussion in Section8with some conclusions and directions for future work.
https://www.wendangku.net/doc/6018855137.html,
2.PRELIMINARIES
Throughout this paper,we take an unorthodox view of constraints.The constraints that we consider do not re-strict the valid database instances.Rather,they constrain the set of valid(in our terminology consistent)answers that can be obtained when posing a query on the database.To avoid confusion,we will refer to such constraints as query constraints.In this paper,we will consider sets of query constraints which consist of at most one key constraint per relation of the query.
Let R be a relational schema,and D be a database over R.We are given a set of query constraintsΣ,where the database may be inconsistent with respect toΣ.We use a common de?nition for consistent query answer that is based on the concept of a database repair,de?ned by Arenas et al.
[2].A repair D R of D is an instance of R such that D R sat-is?es the query constraints ofΣ,and D R di?ers minimally from D.In this case,minimality is de?ned with respect to the symmetric di?erence between D and D R,denoted as ?(D,D R).
Dfn1(Repair[2]).Let D be a database.A database D R is a repair of D with respect toΣif D R satis?esΣand there is no database D satisfyingΣwhere?(D,D )??(D,D R).
Notice that repairs need not be unique.In fact,even for keys there may be an exponential number of them.Intu-itively,each repair corresponds to one possible way of“clean-ing”the inconsistent database.For keys,a repair will be a subset of D that contains exactly one tuple for each key value in D.
Example 2.In our example of Figure1,we have the fol-lowing four repairs:D R1={t1,t3,t4},D R2={t1,t3,t5}, D R3={t2,t3,t4},D R4={t2,t3,t5}.Each repair is a con-sistent database that is as close as possible to the inconsistent database of Figure1.
The notion of repair is used to give a precise meaning to query answering over inconsistent databases[2].In partic-ular,a consistent query answer is required to appear in the result of a query on every repair of the inconsistent database.
Dfn2(Consistent Query Answer).Let D be a data-base,q be a query,andΣbe a set of query constraints.The consistent query answers for q on D are de?ned as the set
D R is a repair of D wrtΣ
q(D R)
In contrast to consistent answers,we could also consider possible answers,where a possible answer is an answer on some repair(that is,it is the union of the answers to q over all the repairs).Note that whenΣincludes only key constraints and q is a monotone query,the original query q on D returns the set of possible answers.
For set semantics,we are only concerned with?nding the set of tuples that occur in the query result for every repair. Under bag semantics,the multiplicity of a tuple in the con-sistent query answer is the minimum multiplicity from any repair.
Our approach to compute consistent answers is based on query rewriting.Speci?cally,given an SQL query q and a set of key query constraintsΣ,we will rewrite q into another SQL query Q c that retrieves the consistent answers for q. The rewriting is done independently of the data,and works for every inconsistent database.Some rewriting strategies for limited classes of queries have been proposed in the lit-erature[2,7].The strategy presented in this paper is moti-vated by our previous work on rewriting conjunctive queries into?rst-order logic queries[11].In Sections3and4,we consider not only conjunctive queries(that is,SPJ queries with set semantics),but also queries with aggregation and bag semantics.
In this paper,we consider setsΣof query constraints that consist of at most one key constraint per relation of the query.A key query constraint declares a set of attributes X as the key of a relation.Each attribute in X is a key attribute,all other attributes of the relation are non-key at-tributes.
To de?ne the class of queries that can be handled by Con-Quer,we?rst introduce the notion of a join graph[11].
Dfn3(join graph).Let q be a SQL query.The join graph G of q is a directed graph such that:
?the vertices of G are the relations used in q;and
?there is an arc from R i to R j if a non-key attribute of
R i is equated with a key attribute of R j.
We present query rewritings for tree queries.Such queries can have two kinds of joins.First,they can have joins be-tween key attributes.Second,they can have joins from non-key attributes of a relation(possibly a foreign key)to the primary key of another relation.Arguably,these two types of joins are the most commonly used in practice(and cer-tainly the most common in standards like TPC-H).
Dfn4(tree query).We say that a select-project-join-group-by query q is a tree query if(1)every join condition of q involves the key of at least one relation;(2)the join graph of q is a tree.We consider only queries containing equi-joins (no inequality joins).The selection conditions may contain comparisons(e.g.,<)or functions.Each relation may be used at most once in the query.The query may contain aggregate expressions.
Note that the previous de?nition restricts the non-key to key joins of the query to be acyclic,and does not permit non-key to non-key joins(since every join must involve the key of a relation).
3.JOIN QUERIES
In this section,we present ConQuer’s rewriting strategy for tree queries without aggregation or grouping.In Section 4,we will consider a larger class of queries that includes aggregation.We illustrate the rewriting approach with the next example.
Example 3.Consider a query q2,which retrieves the or-ders placed by customers with an account balance over1000. q2:select o.orderkey
from customer c,order o
where c.acctbal>1000and o.custfk=c.custkey
order customer
order clerk cust cust acct
key fk key bal s1o1ali c1t1c12000
s2o2jo c2t2c1100
s3o2ali c3t3c22500
s4o3ali c4t4c32200
s5o3pat c2t5c32500
s6o4ali c2
s7o4ali c3
s8o5ali c2
Figure2:An inconsistent database with order and customer relations
with Candidates as(
select distinct o.orderkey
from customer c,order o
where c.acctbal>1000and o.custfk=c.custkey), Filter as(
select o.orderkey
from Candidates Cand
join order o on Cand.orderkey=o.orderkey
left outer join customer c
on o.custfk=c.custkey where c.custkey is null or c.acctbal≤1000) select orderkey
from Candidates Cand
where not exists(select*from Filter F
where Cand.orderkey=F.orderkey) Figure3:The rewriting Q c2for query q2
The query constraints are that orderkey should be the key of relation order,and custkey should be the key of relation customer.We will consider the database of Figure2,where both relations are inconsistent with respect to the query con-straints.
The consistent query answers for q2on the database are {o2,o4,o5}.The reason that order o1is not a consistent answer is that c1,the customer that placed order o1,is not known(for certain)to have an account balance over1000. The order o3is not a consistent answer because it might have been placed either by customer c2or c4,the latter of which is not a tuple in the customer relation.
In Figure3,we show a query rewriting Q c2that computes the consistent answers for q2.Notice that there are two sub-queries named Candidates and Filter.Candidates cor-responds to the original query q2,except that it uses the distinct keyword.The reason for this is that orderkey is a key,and therefore its values appear exactly once in ev-ery repair.In this case,the result of applying Candidates to the database is{o1,o2,o3,o4,o5}.The query Filter re-turns the orders that should be“?ltered out”from the result of Candidates because they are not consistent answers.In this case,Filter returns{o1,o3}.The order o1is returned by Filter because tuple s1joins with tuple t2,which corre-sponds to a customer whose account balance is below1000 (c.acctbal≤1000in the Filter).The order o3is in Filter because o3appears in tuple s4.This tuple does not satisfy the join condition of q2because c4does not appear in re-with Candidates as(
select distinct o.orderkey,o.clerk
from customer c,order o
where c.acctbal>1000and o.custfk=c.custkey), Filter as(
select o.orderkey
from Candidates Cand
join order o on Cand.orderkey=o.orderkey
left outer join customer c
on o.custfk=c.custkey where c.custkey is null or c.acctbal≤1000
union all
select orderkey
from Candidates Cand
group by orderkey
having count(*)>1)
select clerk
from Candidates Cand
where not exists(select*from Filter F
where Cand.orderkey=F.orderkey) Figure4:The rewriting Q c3for query q3
lation customer.Notice that Filter computes a left-outer join between order and customer.Since tuple s4does not join with any tuple of customer,o3appears together with a null value for attribute custkey in the left-outer join.There-fore,the condition c.custkey is null is satis?ed,and o3 is returned by the?lter.
The rewriting Q c2?nally retrieves the orders in the result of Candidates that are not in Filter(i.e.,they are not ?ltered out).In this case,it returns{o2,o4,o5},which is the consistent answer.
To generalize the previous example to an algorithm for tree queries,we must consider how to handle projection. Note that query q2returns the key of the relation at the root of the join graph.But if we modify it to return other attributes instead,we must augment the rewriting.We il-lustrate this in the next example.
Example 4.Consider a query q3which retrieves the clerks who have processed orders for customers with a balance over 1000.
q3:select o.clerk
from customer c,order o
where c.acctbal>1000and o.custfk=c.custkey Note that the only di?erence with query q2of the previ-ous example is that we are projecting on clerk instead of orderkey.We will again consider the inconsistent database of Figure2,and the key query constraints orderkey and custkey.
A query rewriting Q c3that computes the consistent answers for q3is given in Figure4.Note that in the Candidates sub-query,we project not only on clerk but also on orderkey. The reason is that the“?ltering”must be done based on the key of the relation.In general,we will?lter using the key attributes of the relation at the root of the join graph of the query(order in this case).If we apply Candidates over the database we get{(o1,ali),(o2,jo),(o2,ali),(o3,pat),(o4,ali),
(o5,ali)}.As in the previous example,the tuples for o1and o3should be?ltered out.Additionally,in this case,we should ?lter out the tuples for o2.The reason is that the clerk of o2may be jo in some repairs,and ali in others.Hence, o2should not contribute its clerks to the consistent query answer of q3.This is captured with the second subquery of Filter in Figure4.
The rewriting Q c3?nally takes the tuples of the result of Candidates whose order is not retrieved by Filter,and projects on the clerk attribute.The?nal result is{ali,ali}, which is the consistent answer.Notice that the rewriting computes not only the fact that ali is a consistent answer, but also the correct multiplicity.
In Figure5,we give the rewriting algorithm Rewrite-Join for tree queries without aggregation.The subquery Candidates corresponds to the original query,except for its select clause.First,this clause uses the distinct keyword. Second,it projects on the key attributes of the root relation of the join graph(denoted as Kroot).We will call the values computed by Candidates the candidates for the consistent answers.
We assume that all tuple variables have the name of the relations of the original query.This condition can be re-laxed,as long as tuple variables are used consistently in the expressions N SC,LOJ and KJ.Furthermore,for nota-tional convenience,we take the liberty of treating vectors of attributes as if they were a single attribute.
The?rst subquery of Filter returns the set of candidates that are not present in the query answer from at least one repair.To ensure that Filter considers all candidates,there is an inner join between Candidates and the relation at the root of the join graph(Rroot).The relation Rroot is joined with the rest of the relations of the original query(expression LOJ).Since we want to be able to detect the cases in which non-key to key joins are not satis?ed,we need to perform a left-outer join rather than an inner join.This can be done in our case because we are considering queries whose join graph is a tree.In particular,the left-outer join of the relations is obtained starting at the relation at the root of the join graph (tree),and recursively traversing it in the direction of its arcs (that is,from a relation joined on a non-key attribute to a relation joined on its key).We denote the expression with LOJ,and present the procedure to construct it in Figure6. We can now explain the where clause of the?rst subquery of Filter.First,it contains an expression KJ that consists of the key-to-key joins of the query.These joins do not need to be considered in the left-outer join LOJ.To under-stand why,notice that if a candidate satis?es a key-to-key join,then it must satisfy it in every repair(since every key value appears in every repair).Second,the subquery checks whether there is a tuple which does not satisfy a join of the original query.This is done by checking whether there is a null value in the left-outer join.Finally,it checks whether there is some selection condition of the original query that is not satis?ed(expression N SC).
The second subquery of Filter takes care of the projected attributes of the original query,as explained in Example4. Finally,the query rewriting returns the tuples for the can-didates that were not?ltered out.RewriteJoin is a correct query rewriting algorithm for tree queries without aggrega-tion,as stated in the next theorem.
RewriteJoin(q,Σ)
Given a query q of the form
select S
from Rroot,R1,...,R m
where KJ and N KJ and SC
order by O
where
Rroot is the relation at the root of the join graph
KJ is a conjunction of key-to-key join predicates
N KJ is a conjunction of nonkey-to-key join predicates
SC is a conjunction of selection predicates
Let
Kroot be the attributes of the key of Rroot
K1,...,K m be the attributes of the keys of R1,...,R m
N SC be the negation of the selection predicates SC of q
LOJ be the left outer-join of the join graph of q,
obtained as shown in Figure6
The rewriting Q c of q is the following:
with Candidates as(
select distinct Kroot,S
from Rroot,R1,...,R m
where KJ and N KJ and SC)
Filter as(
select Kroot
from Candidates C
join Rroot on C.Kroot=Rroot.Kroot
left outer join LOJ
where KJ and
(R1.K1is null or...or R m.K m is null
or N SC)
union all
select Kroot
from Candidates C
group by Kroot
having count(*)>1)
select S
from Candidates C
where not exists(select*from Filter F
where C.Kroot=F.Kroot)
order by O
Figure5:Query rewriting algorithm for queries without aggregation
Theorem 1.Let q be a tree query without aggregate op-erators,andΣbe a set of query constraints containing at most one key constraint per relation.Then,the rewriting RewriteJoin(q,Σ)computes the consistent query answers for q wrtΣon every database D.
4.AGGREGATION QUERIES
In this section,we present ConQuer’s rewriting strategy for tree queries that may have grouping and aggregation. The obvious extension of the semantics of consistent answers is to return values for the aggregate expressions that hold in every repair.However,as we motivate in the next example, this may be overly restrictive in some cases.
Example 5.Consider a query q4that retrieves the sum of all account balances in the customer relation.Again, custkey is the key query constraint.
LOJ(T):
Let R be the relation at the root of T
If T is a leaf then return
else
Let T1,...,T m be the subtrees of the root of T
for i=1to m
Let N i be non-key attrs of R that are
equated with the key K i of R i
return“R1on R.N1=R1.K1
left outer join...
left outer join R m on R.N m=R m.K m
left outer join LOJ(T1)
left outer join...
left outer join LOJ(T m)”
Figure6:Left outer-join of join graph T
cust nation mkt acct
key key segment bal
t1c1n1building1000
t2c1n1building2000
t3c2n1building500
t4c2n1banking600
t5c3n2banking100
Figure7:Inconsistent instance of customer
q4:select sum(acctbal)as sumBal
from customer
We will consider the inconsistent database of Figure7.In this case,there are four repairs:D R1={t1,t3,t5},D R2= {t1,t4,t5},D R3={t2,t3,t5}and D R4={t2,t4,t5}.In repair D R1,the sum of account balances is1600;in D R2,it is 1700;in D R3,2600;and in D R4,2700.Hence,the consistent query answers to q4are empty.In fact,it su?ces to have one customer with two(inconsistent)account balances in order to have an empty answer for the aggregation on all customers.
Arenas et al.[3]proposed to return bounds for the ag-gregate expressions,rather than exact values.For instance, in the previous example we can say that1600≤sumBal≤2700.In order to consider such ranges,we need to slightly modify the semantics of consistent query answers to what we call range-consistent query answers.
We will consider SQL queries of the following form: select G,agg1(e1)as E1,...,agg n(e n)as En
from F
where W
group by G
where G is the set of attributes we are grouping on,and agg1(e1),...,agg n(e n)are aggregate expressions with func-tions agg1,...,agg n,respectively.We will assume that the select clause renames the aggregate expressions to E1,..., En.Notice that we are focusing on queries where all the at-tributes in the group by clause appear in the select clause. This is a restriction because,in general,SQL queries may have some attributes in the group by clause which do not appear in the select clause(although not vice versa).
In the de?nition of range-consistent query answers,we will give a range for each value of G that is a consistent answer. Therefore,we will use a query q G that consists of q with all the aggregate expressions removed from the select clause: q G:select G
from F
where W
group by G
We now introduce the de?nition of range-consistent query answers,and illustrate it with an example.
Dfn5(Range-Consistent Query Ans).Let D be a database,q be a query,andΣbe a set of query constraints. We say that(t,r)is a range-consistent query answer for q on D if
1.t is a consistent answer for q G on D,where q G is query
q with all the aggregate expressions removed;and
2.r=(min E1,max E1,...,min En,max En),and for each
i such that1≤i≤n:
?min Ei≤ΠEi(σG=t(q(D R)))≤max Ei for every
repair D R;and
?ΠEi(σG=t(q(D R)))=min Ei,for some repair D R;
and
?ΠEi(σG=t(q(D R)))=max Ei,for some repair D R.
Example 6.Consider the following query,which retrieves the total account balance for customers in the building sector, grouped by nation.Again,custkey is a key query constraint. q5:select nationkey,sum(acctbal)
from customer
where mktsegment=’building’
group by nationkey
Let q G be query q5with its aggregate expression removed. q G:select nationkey
from customer
where mktsegment=’building’
group by nationkey
Consider again the database of Figure7.It is easy to see that nation n1is the only consistent answer to q G.There-fore,the range-consistent answer consists of a range of val-ues for n1.
Recall that there are four repairs for the database:D R1= {t1,t3,t5},D R2={t1,t4,t5},D R3={t2,t3,t5}and D R4= {t2,t4,t5}.The result of applying q5on the repairs is the following:q5(D R1)={(n1,1500)};q5(D R2)={(n1,1000); q5(D R3)={(n1,2500)};and q5(D R4)={(n1,2000)}.Hence, the consistent answers to q5is the set{(n1,1000,2500)},be-cause the sum of the account balances for customers in the building sector and nation n1is:
?between1000and2500,in every repair;
?1000in repair D R2;
?2500in repair D R3.
Before presenting the rewriting that computes the range-consistent query answers,let us illustrate the approach with some examples.
Example7.Suppose that we want to obtain a rewriting that computes the range-consistent answers for query q5of the previous example.We are going to obtain upper and lower bounds for the account balance of each customer,and then sum the account balances.As in the previous section, we are going to?lter some of the customers.We will use the?lter for q G,which can be obtained using the algorithm RewriteJoin of Figure5.Intuitively,the?lter retrieves the customers which appear in some tuple that does not satisfy q G.
Consider again the database of Figure7.When we apply the?lter to the customer table,c2and c3are?ltered out. The customer c1is not?ltered because its two tuples(t1and t2)satisfy query q G.In repairs D R1and D R2,c1contributes an account balance of1000.In D R3and D R4,it contributes 2000.Therefore,it contributes a minimum of1000and a maximum of2000.We can capture this with the following query:
with UnFilteredCandidates as(
select custkey,nationkey,
min(acctbal)as minBal,
max(acctbal)as maxBal
from customer c
where mktsegment=’building’
and not exists(select*from Filter
where c.custkey=Filter.custkey) group by custkey,nationkey)
The result of applying UnFilteredCandidates to the in-consistent database is{(c1,n1,1000,2000)}.Notice that the ?lter is necessary because we would otherwise get the tuple (c2,n1,500,500)in the result,which states that customer c2contributes an amount of500in every repair.This is not correct,since in repairs D R2and D R4(i.e.,the repairs where t4appears),customer c2does not satisfy query q G and therefore does not contribute to the sum of account balances. Therefore,c2contributes a minimum of0and a maximum of500.This is captured with the following query:
with FilteredCandidates as(
select custkey,nationkey,
0as minBal,
max(acctbal)as maxBal
from customer c
where mktsegment=’building’
and exists(select*from Filter
where Filter.custkey=c.custkey) and exists(select*from QGCons
where QGCons.nationkey=c.nationkey) group by custkey,nationkey)
The result of FilteredCandidates is{(c2,n1,0,500)}. In addition to checking that the customer is?ltered,we check that the nation(i.e.,the attribute in the group by of the original query)appears in the result of the consistent an-swers to q G(denoted as QGCons in the query).This is nec-essary because we do not want to retrieve ranges for the nations that are not consistent answers.
Finally,we obtain the range-consistent answers by sum-ming up the lower and upper bounds for each nation in the result of FilteredCandidates and UnfilteredCandidates, as follows:
select nationkey,
sum(minBal),sum(maxBal)
from(select*from FilteredCandidates
union all
select*from UnfilteredCandidates)
group by nationkey
In the previous example,all the numerical values were positive.The following example shows how to produce a rewriting that deals with negative values as well.
Example8.Consider query q5,and a database with the following customer relation.The only di?erence with the relation of Figure7is that the account balance in tuple t3is negative.
cust nation mkt acct
key key segment bal
t1c1n1building1000
t2c1n1building2000
t3c2n1building-500
t4c2n1banking600
t5c3n2banking100
The repairs are the same as in the previous example.The result of applying q5on the repairs is the following:q5(D R1)= {(n1,500)};q5(D R2)={(n1,1000)};q5(D R3)={(n1,1500)}; and q5(D R4)={(n1,2000)}.Thus,the range-consistent an-swer to q5is{(n1,500,2000)}.
As in the previous example,customer c1is un?ltered,and customers c2and c3are?ltered.Also,c1contributes to the upper and lower bound of account balances,and c3does not contribute to any of them.On the other hand,the account balance of customer c2in tuple t3contributes to the lower bound of the sum of account balances,as opposed to the up-per bound in the previous example.This is because in the repairs where customer c2appears in tuple t3,the total ac-count balance is reduced rather than increased.In the repairs where customer c2does not satisfy query q G(i.e.,t4is in the repair)the contribution to the total account balance is zero.We capture this with the following query:
with FilteredCandidates as(
select custkey,nationkey,
min(acctbal)as minBal,
0as maxBal
from customer c
where mktsegment=’building’
and exists(select*from Filter
where Filter.custkey=c.custkey) and exists(select*from QGCons
where QGCons.nationkey=c.nationkey) group by custkey,nationkey)
Notice that the only di?erence with FilteredCandidates from the previous example is that there is a value of zero in maxBal,instead of minBal.
The full rewriting RewriteAgg for tree queries(with ag-gregation and grouping)is given in Figure8.The query QGCons retrieves the consistent answers to q G.It is not in-cluded in the?gure because it can be obtained by applying
RewriteAgg(q,Σ)
Given a query q of the form
select G,agg1(e1)as E1,...,agg n(e n)as En
from F
where W
group by G
Let
Rroot be the relation at the root of the join graph of q,
Kroot be the attributes of the key of Rroot,
q G be query q with all the aggregate expressions removed
QGCons be the query that obtains the consistent answers for q G,using RewriteJoin
Filter be the?lter subquery of QGcons
The rewriting Q rc of q is the following:
with UnFilteredCandidates as(
select Kroot,G,min(e1)as minE1,max(e1)as maxE1,
...,min(e n)as minEn,max(e n)as maxEn from F
where W
and not exists(select*from Filter
where F.Kroot=Filter.Kroot) group by Kroot,G),
FilteredCandidates as(
select Kroot,G,
case when minE1>0then0else min(e1)as minE1,
case when maxE1>0then max(e1)else0as maxE1, ...,
case when minEn>0then0else min(e n)as minEn,
case when maxEn>0then max(e n)else0as maxEn
from F
where W
and exists(select*from Filter
where F.Kroot=Filter.Kroot)
and exists(select*from QGCons
where F.G=QGCons.G)
group by Kroot,G),
select G,agg1(minE1),...,agg n(minEn),...,
agg1(maxE1),...,agg n(maxEn)
from(select*from FilteredCandidates
union all
select*from UnfilteredCandidates)
group by G
Figure8:Rewriting for queries with aggregation the rewriting algorithm RewriteJoin of the previous sec-tion.Recall that in the examples we obtained lower and up-per bounds for each customer and nation.The customer was the key attribute of the relation at the root of the join graph (denoted by Kroot in the algorithm).The nation was the at-tribute we were grouping on(denoted with G).Thus,in the algorithm we obtain bounds for the attributes Kroot and G. We take the liberty of denoting by F.Kroot=Filter.Kroot and F.G=QGCons.G the join between all the attributes of Kroot and G(associated to the appropriate relations of F) with the corresponding attributes of Filter and QGCons. The query UnFilteredCandidates obtains the bounds for the values of Kroot that are not?ltered,and therefore con-tribute to both bounds.The query FilteredCandidates obtains the bounds for the values that are?ltered,and therefore may contribute zero to some of the bounds.The case statements are used to select the appropriate upper
order customer order clerk cust cons cust acct cons
key fk key bal
s1o1ali c1y t1c12000n s2o2jo c2n t2c1100n s3o2ali c3n t3c22500y s4o3ali c4n t4c32200n s5o3pat c2n t5c32500n s6o4ali c2n
s7o4ali c3n
s8o5ali c2y
Figure9:Annotated version of the database of Fig-ure2
and lower bounds,depending on whether they are positive or negative values.This generalizes the strategy presented in Example8for negative values.The?nal result is ob-tained by aggregating the upper and lower bounds from UnFilteredCandidates and FilteredCandidates using the aggregation functions of the original query.
Theorem 2.Let q be a tree query that may contain ag-gregate expressions(with functions MAX,MIN,SUM),andΣbe a set of query constraints containing at most one key constraint per relation of the query.Then,the rewriting RewriteAgg(q,Σ)computes the range-consistent query an-swers for q with respect toΣon every database D.
5.ANNOTATED DATABASES
If the query constraints are known in advance,ConQuer can process the database o?ine in order to store information about constraint violations.In particular,it can annotate every tuple of the database with a?ag that states whether the tuple(might)violate a key constraint.This?ag is then used to produce optimized query rewritings.Note that a standard query optimizer would not be able to exploit the annotations because it is unaware of their semantics(and the semantics of consistent query answering in general).
In Figure9,we show an annotated version of the database of Figure2.The annotations are made assuming that the attribute orderkey is the key of the order relation,and custkey is the key of the customer relation.Note that the schema of every relation is augmented with an attribute cons that stores the annotation.If the value of cons in a tu-ple is y ,then the tuple satis?es the key constraint;a value of n indicates that it might violate the constraint.We illustrate the optimized rewriting with the next example.
Example9.We will consider again query q2from exam-ple3,which retrieves the orders placed by customers with an account balance over1000.The query constraints are again that orderkey and custkey are keys of their relations.We assume that ConQuer knows them in advance,and has pro-duced the annotated database of Figure9.
q2:select orderkey
from customer c,order o
where c.acctbal>1000and o.custfk=c.custkey
Note that tuples s8and t3have a value of y in their cons attributes,meaning that they do not violate any constraint.
If we join s8with t3,we get a tuple that satis?es query q2. Furthermore,it is easy to see that this will be the only tuple in the result for order o5.Thus,it must be a consistent answer.
In general,if a tuple is produced from the join of tuples that satisfy the constraints,it is a consistent answer.Thus, it is not necessary to consider it in the Filter subquery of the rewriting.Note,however,that this is not the case even if some(but not all)of the tuples that are joined satisfy the constraints.For example,consider the join of tuple s1 (annotated with y )and tuple t1(annotated with n ).If we join them,we get a tuple that satis?es q2.However,it is not a consistent answer because the result of joining s1with another tuple(t2)does not satisfy the query.
To keep track of the join of tuples violating a constraint, we augment the Candidate subquery of the rewriting with an addition attribute consCand.This is a numerical attribute that calculates the number of tuples involving,in this case, an order that joins with tuples violating a constraint.If this value is greater than zero,the tuple might not be in the consistent answer.The Candidates subquery for this example is the following:
select o.orderkey
sum(case when(c.cons=’n’or o.cons=’n’)
then1else0end)as consCand
from customer c,order o
where c.acctbal>1000and o.custfk=c.custkey), group by o.orderkey
In the rewriting presented in Section3,the Filter sub-query joins all tuples of Candidates with the relation at the root of the tree(order in this case).Then,it performs a (possibly costly)left-outer join with all other relations of the original query.We can now avoid joining all tuples of Candidates because we can select only those whose value of consCand is greater than zero.This is because a value of zero in this attribute means that the tuple is known to be in the consistent answer and,therefore,cannot be?ltered out. The following is the Filter subquery for this example. select o.orderkey
from Candidates Cand
join order o on Cand.orderkey=o.orderkey
left outer join customer c
on o.custfk=c.custkey
where Cand.consCand>0
and c.custkey is null or c.acctbal≤1000
Note that the only di?erence with the Filter of Figure3 is that we add the condition Cand.consCand>0to the where clause.Although it is up to the query optimizer to perform this selection before the joins,the results of the next section show that it consistently chooses the appropriate strategy. The?nal subquery of the rewriting is the same as in Figure 3.That is,it returns the orders from Candidates which do not appear in Filter.
6.EXPERIMENTAL EV ALUATION
In this section,we report results for the experiments that we performed in order to quantify the overhead of the rewrit-ings produced by ConQuer.The experiments use realis-tic queries(taken from the TPC-H speci?cation)and large databases.6.1Setup
The experiments were performed on a Dell Optiplex170L PC with a2.8Ghz Intel Pentium4CPU and1GB of RAM (80%of which was allocated to the database manager).The queries were run on DB2UDB version8.1.8under Windows XP Professional.
We present experimental results for six queries taken from the TPC-H speci?cation,which are representative of a va-riety of features supported by our approach.For example, they all have aggregation,and range from one to six joins.4 We focus on queries1,3,4,6,10,and12of the stan-dard.In Figure10,we summarize the main characteristics of these queries.For each query,we give the number of re-lations in the from clause,the selectivity(high means more tuples satisfy the query),the number of attributes in the select clause,and the number of those attributes which are in aggregate expressions.The queries in the TPC-H speci?cation are parameterized,and the standard suggests values for these parameters.In the experiments,we used the suggested values in all the queries.The selectivity we report in Figure10takes these parameters into account.
Relations Selectivity ProjAttrs AggrAttrs Q11high108
Q33low41
Q42low21
Q61low11
Q104low81
Q122low32
Figure10:Queries used in the experiments
The TPC-H speci?cation assumes that databases are con-sistent with respect to the primary keys of the schema.For the experiments,we assumed that primary keys are not part of the schema,but are rather speci?ed as query con-straints.The rewritings that we produced take these query constraints into account.
We experimented with a number of(inconsistent)databases, considering the following parameters:
?The size s of the database.We considered databases
of100and500MB,and1and2GB.A database of1
GB has8million tuples.
?The percentage p of the database that is inconsistent.
For example on a1GB instance(8million tuples)
where p is50%,there are4million tuples that vio-
late the key constraints of the query.We created the
databases in such a way that every relation has the
same value of p as the entire database.We experi-
mented with values of p of0,1,5,10,20,and50.We
deliberately consider high values of p to test the limits
of our approach.
?The number of tuples n that share a common key value
(and hence violate the key constraint),for every key 4Some of the TPC-H queries cannot be handled by our ap-proach because they contain such features as left-outer-joins
or disjunction.There are also queries with nested sub-queries.However,many of them can be decorrelated and unnested.
value in the inconsistent portion of the database.For
example,if n=2,then every key value in the in-
consistent portion of the database appears in exactly
two tuples.We experimented with values of n ranging
from2to50.Note that p and n together determine
the level of inconsistency of the database.
Since the TPC-H data generator(dbgen)creates instances that do not violate the primary key constraints,we devel-oped a simple program that generates inconsistent databases. The program works as follows.Suppose that we want to generate an inconsistent database of1GB where p=10% and n=2.The program?rst invokes the TPC-H data generator and creates a consistent instance of size0.95GB. Then,it selects two sets of tuples of size0.05GB from the database.The tuples are selected randomly from a uniform distribution.One of the sets is used to draw the key values of the con?icting tuples that the program will introduce to the database;the other set is used to obtain non-key values. For each query q,we used ConQuer to generate a rewrit-ten query that takes annotations into account,and another which does not assume an annotated database.In the fol-lowing,we will say that the queries produced by the former strategy are annotation-aware.
Our rewritings contain some common subexpressions spec-i?ed with the WITH clause(such as Candidates and Filter). In the experiments,we found that running times improve considerably when the results of these subexpressions are temporarily stored rather than computed several times for the same query.For some queries,the DB2optimizer real-ized that materialization was the best strategy,but for oth-ers it did not.So to have a consistent comparison,we mate-rialized all common subexpressions using temporary tables. We include the materialization time in the query running times.Furthermore,we ensured that these materialized re-sults were not cached across runs of the queries.
We created indices for the query constraints and for the annotations(the attribute cons).Notice that,since we con-sider databases that violate the key query constraints,they cannot be de?ned as unique keys.For each index,we created statistics using the DB2RUNSTATS command.
6.2Experimental Results
In Figure11,we compare the running times of all queries with the rewritings produced by ConQuer.5The results correspond to a1GB database with5%of inconsistency and n=2.Although the rewritten queries are more expensive, the overhead is reasonable if we take into account that,in general,consistent query answering is much more onerous than standard query answering[4,5].
We calculate the overhead of the rewritten queries as t r?t o
o ,
where t o and t r are the running times of the original and rewritten queries,respectively.For the annotation-aware rewritings of all queries except Q1,the overhead is below 0.52times the running time of the original query.For the ones that do not use annotations,the overhead is less than 0.86for all queries except Q1.We will justify the high over-5To facilitate the comparison of the running times of the other queries,we leave the running times for the rewritings of Q1out of scale.The running time of the annotation-aware rewriting for Q1is8.3minutes.The other rewriting
runs in10.1minutes.
head of the rewritings of Q1momentarily.Of the two rewrit-ing strategies,the one that is annotation-aware consistently produces more e?cient rewritings.The di?erence in the running times of the two rewritings ranges from4%(Q3)to 26%(Q6).We will shortly show a study where the savings of the annotation-aware rewritings are even greater.
We argue that the overhead of the rewritten queries is dominated by the size of the answer to the original query (without considering grouping).This is certainly the case in the database used for the experiments of Figure11,where the rewritings for Q1have the largest overhead.If we re-move all grouping from Q1,we get a result set of5.9million tuples.The size of the result set for all the other queries is below120,000tuples.We justify our conjecture in terms of the query rewriting algorithm RewriteAgg of Figure8. In that?gure,note that the rewritten queries are obtained as the union of two queries:UnfilteredCandidates and FilteredCandidates.The former selects tuples that are not in Filter.The latter selects tuples that are in Filter and in QGCons.QGCons is the query that obtains the consis-tent answers for the original query without aggregation and grouping.Thus,it is obtained with the algorithm Rewrite-Join of Figure5.In this algorithm,the rewritten query re-turns the tuples in the result of Candidates which are not in the result of Filter.Note in Figure5that Filter focuses solely on tuples that come from the result of Candidates.In turn,Candidates is obtained from the original query(with-out grouping and aggregation)except for some changes to its select clause.
We also studied the e?ect of the amount of inconsistency in the database.Here,we report results for one query(Q6) that is representative of the trend that we observed on the other queries as we varied the values of p and n for databases of1GB.In Figure12,we present the running times for databases with a varying percentage p of inconsistency(from 0to50%)for a?xed n=2.We can observe that p has little in?uence on the running time of the original query and the rewriting that is unaware of annotations.The size of the result set of Q6remains constant as we vary the value of p because all databases are of the same size.This is yet another evidence that the size of the result set of the original
query has a considerable impact on the running time of the rewritten queries.
The annotation-aware rewriting is considerably in?uenced by p .In Figure 12,the overhead of the annotation-aware rewritings ranges from 0.02(for p =0%)to 0.56(for p =50%).The reason for this is that the annotation-aware rewriting is designed to focus as much as possible on the consistent portion of the database,and thus bene?ts if the database has a low value of p .Note that on the totally consistent database,the running times of the original query and its annotation-aware rewriting are very close (the over-
In Figure 13,we present the running times for Q6over databases with varying values of n and a ?xed p =10%.Note that the value of n has little in?uence on the running time of any of the two alternative rewritings.
Finally,we studied the scalability of our approach.For this,we employed databases of 100MB,500MB,1GB,and 2GB.To ensure a consistent comparison,we present results for databases where the total number of tuples violating the constraints is kept constant.In particular,in Figure 14we present results for databases with 400,000inconsistent tuples.Thus,the values of p are 2.5,5,10,and 50for the 2GB,1GB,500MB and 100MB databases,respectively.In all databases,we kept n =2.In the ?gure,we report the running time of the annotation-aware rewritings for queries 4,6,and 12.It can observed that the running times grow 7.RELATED WORK
There has been considerable work on the semantics and complexity of consistent query answering.We do not re-all of this work,but instead concentrate on results are the most related to building practical consistent answering systems.The computational complexity of query answering problem has been thoroughly in the literature,for di?erent classes of queries and [4,5].In the case of SPJ queries with one key constraint per relation,the problem is known to be complete in general [4,5].However,there remain practical classes of queries for which the problem is easier to compute.
query rewritings are relevant in our context queries in ?rst-order logic can be translated into Arenas et al.[2]were the ?rst to propose a ?rst-order algorithm,which is applicable to a class of queries quanti?er-free .This class is quite restricted as it re-all attributes to appear in the select clause (and prohibits most projections),unless an attribute has equated to another attribute that is in the select This work was the foundation for Hippo [6],which,best of our knowledge,is the only existing system query answering on large databases.How-the approach taken by Hippo is quite di?erent from
ConQuer.First,Hippo is not based on query rewriting. Rather,it takes the more procedural approach of producing a Java program which computes the consistent answers.Al-though the program does interact with a RDBMS back-end, most of the processing is done by processing a main memory (con?ict-graph)data structure that contains all the tuples that violate the constraints.Hippo extends the select-join query class of Arenas et al.[2]to consider union(disjunc-tion),an operation we are not considering.
The rewriting algorithm presented in this paper is moti-vated by our previous work on rewriting conjunctive queries (that is,SPJ queries with set semantics)into?rst-order logic queries[11].In the current work,we consider not only conjunctive queries but also SPJ queries with aggregation, grouping,and bag semantics.Furthermore,in our previ-ous work,we were not concerned with the running time of the rewritten queries.In principle,?rst-order queries can be translated into SQL.However,the queries produced in [11]have a high level of nesting(proportional to the number of relations in the query)and are therefore very ine?cient. The rewriting algorithm in our current work produces SQL queries with at most one level of nesting and,as shown in Section6,reasonable running times.
Our work on aggregation is inspired by[3],which was the?rst to propose the use of ranges as a semantics for consistent query answering for aggregate expressions,but considers queries with just one aggregated attribute and no grouping.We extend these results to consider general ag-gregation queries with grouping.
There are a number of systems for consistent query an-swering that rewrite queries into powerful https://www.wendangku.net/doc/6018855137.html,mix [10,12]is a notable example of such an approach.In In-fomix,queries are rewritten into disjunctive logic programs. Such programs are computationally more expensive than SQL,but also more expressive and permit rewritings over a very rich class of query constraints.For example,Infomix considers general functional,inclusion,and exclusion query constraints.These systems focus on expressiveness,more than e?ciency and scalability,and therefore address a dif-ferent design point than the one we are considering.To give an idea of the scale of the di?erence,one of the few experi-mental studies available in the literature[10]reports results for databases with at most100tuples violating key query constraints(over a database of50,000tuples).In contrast, one of our experiments was performed on a database with 4million inconsistent tuples(over a total of8million tu-ples).Results for Hippo have also only been reported for a database of up to300,000tuples.Hippo constructs an in-memory con?ict graph which may limit the number of possible con?icts than can be considered[6,7].
Finally,it is worth noting that the semantics of consis-tent query answers is similar to that of certain answers that is widely accepted as an important semantics for data inte-gration[1].For certain answers,the set of possible worlds are the legal instances of a global database,rather than the repairs of an inconsistent database.
8.CONCLUSIONS
We have presented the ConQuer system that,given a set of key query constraints,rewrites SQL queries to SQL queries that return only the consistent answers.We use a strong semantics for“consistent”.An answer is consistent if every repair supports the answer.Such a semantics is useful for identifying potential inconsistencies in a database.How-ever,our rewritings extend naturally to a semantics based on voting(?nd answers supported by at least two repairs), or a semantics under which each tuple is given a probability of being correct[8].We are currently experimenting with rewritings which return the most probable answer over an inconsistent database in which each tuple is assigned a prob-ability of being consistent.
Acknowledgements.We thank Nick Koudas,Mariano Consens,Periklis Andritsos,and Denilson Barbosa for their feedback and help.
9.REFERENCES
[1]S.Abiteboul and https://www.wendangku.net/doc/6018855137.html,plexity of
answering queries using materialized views.In PODS, pages254–263,1998.
[2]M.Arenas,L.Bertossi,and J.Chomicki.Consistent
Query Answers in Inconsistent Databases.In PODS,
pages68–79,1999.
[3]M.Arenas,L.Bertossi,and J.Chomicki.Scalar
Aggregation in FD-Inconsistent Databases.In ICDT,
pages39–53,2001.
[4]A.Cal`?,D.Lembo,and R.Rosati.On the decidability
and complexity of query answering over inconsistent
and incomplete databases.In PODS,pages260–271,
2003.
[5]J.Chomicki and J.Marcinkowski.Minimal-Change
Integrity Maintenance Using Tuple Deletions.To
appear in Information and Computation.CoRR
cs.DB/0212004,2004.
[6]J.Chomicki,J.Marcinkowski,and S.Staworko.
Computing Consistent Query Answers using Con?ict
Hypergraphs.In CIKM,pages417–426,2004.
[7]J.Chomicki,J.Marcinkowski,and S.Staworko.
Hippo:A System for Computing Consistent Answers
to a Class of SQL Queries.In EDBT,pages841–844,
2004.
[8]N.Dalvi and D.Suciu.E?cient Query Evaluation on
Probabilistic Databases.In VLDB,pages864–875,
2004.
[9]T.Dasu and T.Johnson.Exploratory Data Mining
and Data Cleaning.John Wiley,2003.
[10]T.Eiter,M.Fink,G.Greco,and D.Lembo.E?cient
Evaluation of Logic Programs for Querying Data
Integration Systems.In ICLP,pages163–177,2003. [11]A.Fuxman and https://www.wendangku.net/doc/6018855137.html,ler.First-Order Query
Rewriting for Inconsistent Databases.In ICDT,pages 337–351,2005.
[12]D.Lembo,M.Lenzerini,and R.Rosati.Source
Inconsistency and Incompleteness in Data Integration.
In KRDB,2002.
石油行业英文缩写汇总
3DLO 3D long offset seismic survey三维长偏移距野外资料采集 3DHR-HR 3D High resolution –high ???seismic survey 三维高分辨－高密野外资料采集。AAC = adjusted AC; ABI inclination at the drill bit AC acoustic 声波时差 ACN =adjusted CN; ADN Azimuthal neotron density AIT* Array Induction Imager Tool A&S admistration&service AHC Ascendant Hierarchical Clustering ARC Induction Resistivity GR annulus pressure ingrated tool ARI Azimuth resistivity imager方位电阻率成像测井仪 APD Elevation of Depth Reference (LMF) above Permanent Datum APWD apparatus whle drilling ASI Array seismic imager阵列地震成像仪 A VG: Average A VO Amplitude Versus Offset(Amplitude variation with offset calibration)振幅-炮检距 关系 AZI: Azimuth (deg) BBC Buy Back Contract BGG: Background Gas (%) BGP 物探局 BHFP bottomhole flowing pressure BHS :Borehole Status BHT :Bottom Hole Temperature BHTA 声波幅度 BHTT 声波返回时间 BLWH Blue White BML below mud line BOP Blow out preventer BOP stack 防喷器组 BS Bit Size BSW basic?? saturation water(综合含水) CAL borehole diameter 井径 CAST 声波扫描成像测井仪 CBI Central Bank of Iran CBIL 井周声波成像 CBL Cement Bond Log CC correlation coefficient CCAL common core analysis常规岩心分析 CCL Casing Collar Locator CCM Contractors Committee Meeting CDF cumulative density function CDF Calibrated Downhole Force
生产制造英文缩写
EVT(Engineering Verification Test)工程验证测试阶段 DVT(Design Verification Test)设计验证测试阶段 DMT（Design Maturity Test）成熟度验证 MVT（Mass-Production Verification Test）量产验证测试 PVT(Production/Process Verification Test)生产/制程验证测试阶段MP(Mass Production)量产 工程师类: PE: Product Engineer 产品工程师 Process Engineer 制程工程师 ME: Mechanical Engineer 机构工程师 IE：Industrial Engineer 工业工程师 QE: Quality Engineer 品质工程师 SQESupplier Quality Engineer供货商质量工程师 QC quality control 品质管理人员 FQC final quality control 终点质量管理人员 IPQC in process quality control 制程中的质量管理人员 OQC output quality control 最终出货质量管理人员
IQC incoming quality control 进料质量管理人员TQC total quality control 全面质量管理 POC passage quality control 段检人员 QA quality assurance 质量保证人员 OQA output quality assurance 出货质量保证人员 QE quality engineering 品质工程人员 TE Test Engineer 测试工程师 AE Automatic Engineer 自动化工程师 研发类: R&D Research & Design 设计开发部 ID (Industry Design)工业设计 MD (Mechanical Design)结构设计 HW(Hardware) 硬件设计 SW(Software)软件设计 PDM Product Data Management 产品数据管理 PLM product lifecycle management 产品生命周期管理电子设计:
以小见大的写作手法
微课以小见大的写作手法 今天我们一起来学习以小见大的写作手法。第一步我们要明确什么是以小见大？ （提问）某某同学，你对这四个字有什么了解？ 很好！首先从字面意思上看，以小见大是一个四字成语：以者，用也；见者，表现也。顾名思义，它的解释就是用小的表现大的。指通过小事可以看出道理，通过部分可以看出整体，那么作为一种写作手法，我们又要怎么去定义它呢？ 以小见大法，也称小中见大法，即文章作品中，通过小事件和细节来揭示重大主题写作方法。我们要抓住关键字来理解，这句话的关键字就是小事件细节和重大主题，分别是小和大的指代。 这种写作手法有哪些特点呢？ 从材料上来讲：在于抓住一事一物、一情一景；“以小见大”的基本点在于小，一事一物，一情一景都是小的选取对象。 从写法上来讲：从大处着眼、小处落笔；关键在于立意要高，要大，但要注意的是要在尽可能微小之处来体现立意的高大。 从表达效果上来讲：深入发掘，展开联想，为读者创造一个比现实生活更为广阔、更为深远的艺术境界。 （提问）那么有哪些文章用了“以小见大”的写作手法呢？某某同学，你来给大家简要介绍一下？（参考答案：鲁迅的很多作品都用了以小见大的手法，比如《药》就是通过写夏瑜的命运来写整个社会的悲惨命运。） 很好！其实这种写法在文章中比较常见。接下来我们具体来看看几个运用了“以小见大”手法的比较典型的例子： 说到“以小见大”的文章，大家可能第一想到的就是鲁迅先生的《一件小事》，《一件小事》是“以小见大”手法运用的一个典范，描写的是鲁迅出外搭乘人力车，人力车夫在本不用负责的情况下搀扶起被撞倒的老妇人，并将其送至警署的这么一件小事。这篇文章在选材上十分简单，就是日常生活中的一件极其平凡的小事，但从这么一件小事里却折射出了一个“下等人”的高尚的人格力量，这篇文章短小精悍，全文仅一千字左右，但却震撼了人们的心灵。 还有一个很典型的例子是巴金老人的《小狗包弟》，这篇文章选自《随想录》，作者通过描写一条小狗的故事来反映文革的现实，连一条小狗都不能逃过劫难，体现了在“文革”时代任何生命都不能免受侵害的现实。 这两篇文章都运用了“以小见大”的写作手法，而且都运用得非常成功，对小材料的细节描写激发了作者的真情实感，使得文章真实而且感人，达到了很好的效果。 那么以上两篇文章为例，我们来分析一下使用“以小见大”手法的好处？ （提问）同学们先来谈谈吧，某某同学，你是怎么看的？还有人补充吗？ 好，现在我们一起来总结一下： 1、这种艺术处理以一点观全面，给写作者带来了很大的灵活性和无限的表现力； （比如《一件小事》中作者只描写了一位人力车夫的故事，却能将其延伸到整个下层人民甚至整个社会，作者可以极尽表达自己的思想和情感） 2、为读者提供了广阔的想象空间，能产生丰富的联想；（比如从《小狗包弟》 中读者直接获得的情感体验是作者对包弟的歉疚和忏悔，但读者可以思考这份忏悔是否只是对包弟，忏悔又具有怎样的现实意义等，读者想象的空间很大）
【精选】把幸福定格在心中作文600字3篇
【精选】把幸福定格在心中作文600字3篇【精选】把幸福定格在心中作文600字3篇 在日常学习、工作和生活中，大家都经常接触到作文吧，根据写作命题的特点，作文可以分为命题作文和非命题作文。那么，怎么去写作文呢？下面是小编为大家整理的把幸福定格在心中作文600字3篇，欢迎阅读，希望大家能够喜欢。 把幸福定格在心中作文600字篇1 “爸爸去哪儿”这个节目办得太火了，每当我看到那些罩在明星光环下的孩子或笑或泪的纯真举动时，我的脑海中就会浮现出一张万般落寞的脸和一双泫然欲泣的眼。 谁想再听爸爸骂自己两句呢?我的同桌牟春妹就想，那是她的幸福她的梦。我在一个偶然的机会中走进她的内心世界，读懂了她的QQ签名“一蓑烟雨任平生，也无风雨也无晴”。 那天第二节课，毛手毛脚的我只听“嘶”的一声，裤子被椅子边探头探脑的铁钉剐破了，赶紧让同桌牟春妹帮我看看“伤情”。她捂嘴笑道：“挺标准的正三角形，都能看到里边的
内容了。”哎呀!我是女生啊，那么敏感的地方露出“破绽”，还不让淘气鬼们笑翻了?好在我家离学校不远，而且第三节是体育课，课间赶紧跟老师请个短假，牟春妹陪我回家换裤子。 一路闲聊着来到我家。走进老爸为我精心打造的温馨浪漫的小卧室，牟春妹忍不住四下打量着，惊羡不已。我骄傲地说：“都是按照我喜欢的方案装修的，我妈都说老爸宠我，让摘星星他不摘月亮。”抚摩着我的小书桌，她不无嫉妒地说：“你多幸福啊，有自己的小天地。我也想有个自己的小屋，只是担心我妈自己在大屋害怕。”我埋头翻找裤子，不经意地问：“你爸呢?”她停顿了一下：“在家呢。”“让你爸妈在大屋，你自己在小屋不就得了吗?”我想都没想就说。停了一会儿，她才声音低沉地说：“我爸在一年前就去世了。”我一惊，抬头望着她的脸，她的眼圈有点红了。我暗暗责怪自己不小心触到她心灵的伤处，不知道该说什么好。她低下头说：“后来我哥因一场车祸也走了。”屋里静止了片刻，她的眼泪没有落下来，反而轻轻笑了一下：“够惨的吧。以前我也跟你一样，风风火火没心没肺，可是没有爸了你就找不到根，人就像没有依靠了。每逢过节时，我就忍不住想起和爸爸哥哥在一起嬉闹、看电视的情景。我真想让他们陪在我身边，哪怕再听他说我两句、骂我两句，但现在这只能是一个梦了……” 我换好裤子要走时，爸爸下夜班回来了。“下午能请假早点回来吗?你姥爷过生日……不行的话我给你留点好菜。”他
生产制造企业英文及缩写大全
生产制造企业英文及缩写大全 企业生产经营相关英文及缩写之(1)--供应链/物料控制.............. 企业生产经营相关英文及缩写之(2)--生产/货仓.................... 企业生产经营相关英文及缩写之(3)--工程/工序（制程）............ 企业生产经营相关英文及缩写之(4)--质量/体系.................... 业生产经营相关英文及缩写之(5)--营业/采购...................... 企业生产经营相关英文及缩写之(6)--BOM 通用缩写............... 企业生产经营相关英文及缩写之(7)--Shipping 装运.............. 企业生产经营相关英文及缩写之(8)--协议/合同/海关 .............. 企业生产经营相关英文及缩写之(9)--称号/部门/公司 .............. 企业生产经营相关英文及缩写之(10)--认证/产品测试/标准......... 企业生产经营相关英文及缩写之(11)--Genenic 普通书写.......... 企业生产经营相关英文及缩写之(12)--Currencies 货币代码.......
企业生产经营相关英文及缩写之(1)--供应链/物料控制 Supply Chain 供应链? / Material Control 物料控制 APS Advanced Planning Scheduling 先进规划与排期 ATO Assembly To Order 装配式生产 COM Customer Order Management 客户订单管理 CRP Capacity Requirement Planning 产量需求计划 EMS Equipment Management System / Electronic Management Syste m 设备管理系统/ 电子管理系统 ERP Enterprise Resource Planning 企业资源规划 I/T Inventory Turn 存货周转率 JIT Just In Time 刚好及时- 实施零库存管理 MBP Master Build Plan 大日程计划-主要的生产排期 MES Management Execution System 管理执行系统 MFL Material Follow-up List 物料跟进清单 MMS Material Management System 物料管理系统 MPS Master Production Scheduling 大日程计划-主要的生产排期MRP Material Requirement Planning 物料需求计划 MS Master Scheduling 大日程计划-主要的生产排期 MTO Make To Order 订单式生产 MTS Make To Stock 计划式生产 OHI On Hand Inventory 在手库存量 PSS Production Scheduling System 生产排期系统 SML Shortage Material List 缺料物料单 VMI Vendor Managed Inventory 供应商管理的库存货 UML Urgent Material List 急需物料单
有关把幸福定格在心中作文600字三篇
有关把幸福定格在心中作文600字三篇有关把幸福定格在心中作文600字三篇 在平平淡淡的日常中，大家最不陌生的就是作文了吧，作文是人们以书面形式表情达意的言语活动。你写作文时总是无从下笔？下面是小编为大家收集的把幸福定格在心中作文600字3篇，欢迎阅读，希望大家能够喜欢。 把幸福定格在心中作文600字篇1 “爸爸去哪儿”这个节目办得太火了，每当我看到那些罩在明星光环下的孩子或笑或泪的纯真举动时，我的脑海中就会浮现出一张万般落寞的脸和一双泫然欲泣的眼。 谁想再听爸爸骂自己两句呢?我的同桌牟春妹就想，那是她的幸福她的梦。我在一个偶然的机会中走进她的内心世界，读懂了她的QQ签名“一蓑烟雨任平生，也无风雨也无晴”。 那天第二节课，毛手毛脚的我只听“嘶”的一声，裤子被椅子边探头探脑的铁钉剐破了，赶紧让同桌牟春妹帮我看看“伤情”。她捂嘴笑道：“挺标准的正三角形，都能看到里边的内容了。”哎呀!我是女生啊，那么敏感的地方露出“破绽”，
还不让淘气鬼们笑翻了?好在我家离学校不远，而且第三节是体育课，课间赶紧跟老师请个短假，牟春妹陪我回家换裤子。 一路闲聊着来到我家。走进老爸为我精心打造的温馨浪漫的小卧室，牟春妹忍不住四下打量着，惊羡不已。我骄傲地说：“都是按照我喜欢的方案装修的，我妈都说老爸宠我，让摘星星他不摘月亮。”抚摩着我的小书桌，她不无嫉妒地说：“你多幸福啊，有自己的小天地。我也想有个自己的小屋，只是担心我妈自己在大屋害怕。”我埋头翻找裤子，不经意地问：“你爸呢?”她停顿了一下：“在家呢。”“让你爸妈在大屋，你自己在小屋不就得了吗?”我想都没想就说。停了一会儿，她才声音低沉地说：“我爸在一年前就去世了。”我一惊，抬头望着她的脸，她的眼圈有点红了。我暗暗责怪自己不小心触到她心灵的伤处，不知道该说什么好。她低下头说：“后来我哥因一场车祸也走了。”屋里静止了片刻，她的眼泪没有落下来，反而轻轻笑了一下：“够惨的吧。以前我也跟你一样，风风火火没心没肺，可是没有爸了你就找不到根，人就像没有依靠了。每逢过节时，我就忍不住想起和爸爸哥哥在一起嬉闹、看电视的情景。我真想让他们陪在我身边，哪怕再听他说我两句、骂我两句，但现在这只能是一个梦了……” 我换好裤子要走时，爸爸下夜班回来了。“下午能请假早点回来吗?你姥爷过生日……不行的话我给你留点好菜。”他一边洗脸一边说着，还嘱咐我，“慢点走，靠边儿。”
石油化工英语常用缩写
石油化工英语常用缩写(第一版) 序号缩写英文中文 1 AC Air Conditioning 空气调节装置 2 AGO Atmospheric gas oil 常压瓦斯油 3 AML Approved Manufacturers' List 批准的厂商名单 4 APE Area Project Engineer 区域项目工程师 5 AR Atmospheric residue 常压渣油 6 ARDS Atmospheric residue desulfurization 常压渣油加氢脱硫 7 ASME American Society of Mechanical Engineers 美国机械工程师协会 8 BD Business Director 商务主任 9 BD Business Development 市场部 10 BEDP Basic Design Engineering Package 基础设计包 11 BFW Boiler feed water 锅炉给水 12 BL Battery limits 界区 13 BEDD Basic Engineering Design Data 基础工程设计数据 14 BM Bill of Material 材料表 15 BOD Basis of Design 设计基础 16 BOD Biological Oxygen Demand 化学需氧量 17 BP Boiling point 沸点 18 BS Bright stock 光亮油 19 BSI British Standards Institute 英国标准协会 20 BTEX Benzene, toluene, ethyl benzene, xylene 苯,甲苯,乙苯,二甲苯 21 BTU British thermal unit 英热单位 22 BTX Benzene, toluene, xylene 苯,甲苯,二甲苯 23 C Construction 施工 24 CAD Computer Aided Design 计算机辅助设计 25 CADD Computer Aided Design and Drafting 计算机辅助设计和绘图 26 CCR Conradson carbon residue 康氏残炭 27 CCR Continuous Catalyst Regeneration 催化剂连续再生 28 CDU Crude distillation unit 原油蒸馏装置 29 CGO Coker gas oil 焦化瓦斯油 30 CI Cetane index 十六烷指数 31 CL Center line 中心线 32 CM Construction Manager 施工经理 33 CN Conference Note 会议纪要 34 COD Chemical oxygen demand 化学需氧量 35 CPDP Chinese Preliminary Design Package 中国初步设计包 36 CPM Critical Path Method 关键路径法 37 CR Catalytic Reforming 催化重整 38 CS Carbon Steel 碳钢 39 CW Cooling Water 冷却水 40 FEED Front End Engineering Design 前期工程设计 41 GB GUO BIAO 国标 42 GCD Guaranteed Completion Date 保证完成日期 43 GG Gauge glass 玻璃液面计 44 GHSV Gaseous hourly space velocity 气体体积空速 45 GPH Gas phase hydrogenation 气相加氢 46 GSN Global Supply Network 全球供应网络 47 GTG Gas Turbine Generator 燃气涡轮发电机 48 GW Gross weight 毛重 49 HAZID Hazard Identification Review 危险识别审查 50 HAZOP Hazard and Operability Study 危险与可操作性研究
制造业中常用的英文缩写
制造业中常用的英文缩写 工业常用的英文缩写 品质人员名称类 QC quality control 品质管理人员 FQC final quality control 终点质量管理人员 IPQC in process quality control 制程中的质量管理人员 OQC output quality control 最终出货质量管理人员 IQC incoming quality control 进料质量管理人员 TQC total quality control 全面质量管理 POC passage quality control 段检人员 QA quality assurance 质量保证人员 OQA output quality assurance 出货质量保证人员 QE quality engineering 品质工程人员 品质保证类 FAI first article inspection 新品首件检查 FAA first article assurance 首件确认 CP capability index 能力指数媵 CPK capability process index 模具制程能力参数 SSQA standardized supplier quality audit 合格供货商品质评估 FMEA failure model effectiveness analysis 失效模式分析 FQC运作类 AQL Acceptable Quality Level 运作类允收品质水准 S/S Sample size 抽样检验样本大小 ACC Accept 允收 REE Reject 拒收 CR Critical 极严重的 MAJ Major 主要的 MIN Minor 轻微的 Q/R/S Quality/Reliability/Service 品质/可靠度/服务 P/N Part Number 料号藊 L/N Lot Number 批号 AOD Accept On Deviation 特采 UAI Use As It 特采 FPIR First Piece Inspection Report 首件检查报告 PPM Percent Per Million 百万分之一 制程统计品管专类 SPC Statistical Process Control 统计制程管制 SQC Statistical Quality Control 统计质量管理 GRR Gauge Reproductiveness & Repeatability 量具之再制性及重测性判断量可靠与否DIM Dimension 尺寸 DIA Diameter 直径 N Number 样品数
以小见大的亲情作文优秀3篇
以小见大的亲情作文优秀3篇 以小见大的亲情作文（一）： 生活中有许多感人的事，它们像海底的一颗颗珍珠，珍藏在我们心中！ 一个阳光明媚的早晨，院子尽是小鸟清脆的歌声――我该去上学了！ 爸爸推着自行车，我坐在后座准备带我去上学，正在跟妈妈描述昨晚做梦时的情形，并且用手比划着，爸爸什么也不知，只顾着往前走，就在准备要过门槛的那一刻，意外发生了。自行车往前一拱，顿时我身子倾斜，两手不知所措“蹼蹬”一声，我重重的摔倒在地。地下满是尖尖的石头，我的头流淌着鲜血，失声痛哭起来，这声足能够震动山岗。爸妈一看这情形着急起来，爸爸立刻抱起我，飞奔向医院，一边跑一边安慰我但是，不知是谁惹怒了雨神，突然下起蒙蒙细雨，随着时间一分一秒的过去，下起了倾蓬大雨，路上的行人见状纷纷回家，这时爸爸皱起了眉头，不管下着多大的雨，不管路地有多么滑，爸爸都紧紧地抱着我，大步向医院奔去，最后到医院了，爸妈的衣服全湿透了，而我却是浓浓的暖意，感动地泪水夺眶而出。 爸妈我爱您们！ 以小见大的亲情作文（二）： 以小见大的亲情 父亲也真搞笑，老远的给我送月饼来，还有两个梨和一小撮茶叶，这些东西加起来也不到车费的三分之一呢。
和同学们瓜分了月饼和梨，那一小撮茶叶却弄丢了。或许是当垃圾给扫掉了吧。我一翻垃圾篮，果然在那，幸好有袋子装着。 我把那茶叶倒进开水中，刚好能泡上一杯浓浓的茶。就是这杯浓热的茶，使我又一次不能入眠。一整个下午，我就静静地想着过去的事。 我们村子里的人除了待客和供神鬼，自我是很少喝茶的，连开水也难得喝上一口。渴了就舀上一大碗带点粥的米汤咕噜咕噜地灌下去。只有我们家，四姐弟都喜欢喝茶，而我母亲向来是不主张我们喝茶的，在她眼里喝茶跟喝药一个样，只是在吃多了油腻的东西的才特许我们喝上一两杯。但我们喝得多了，她也就不怎样管我们了，只是她还是一口也不喝，除非拉肚子。说来好笑，我母亲认为浓茶是能够治拉肚子的，我小时候就十分信奉这种说法。肚子不舒服了就偷一把茶叶塞进嘴里，用口水慢慢地将它泡软，然后就咀嚼起来，有时连渣也全吞了下去。虽然有点苦，但为了肚子，我那时就很勇敢，况且吃完后很长一段时间口中还甘甜甘甜的。我很喜欢那种感觉。也真是奇怪，那方法每次都灵验。我曾把这方法传授给别的小孩子，但他们都爱不了那苦。 我渐渐长大，再也不吃茶叶了，却还是喜欢喝茶，个性是早上起来，先泡上一杯浓茶再去刷牙洗脸运动，回来时那茶已差不多泡好了。捧上一本小说边喝边看，那真是人生一大快事。 这样的快事在学校里是享受不到的。因为学校里太热闹，生活节
幸福在心中作文600字
幸福在心中作文600字 人人都渴望幸福，人人都在追求幸福。下面是为你了“幸福在心中作文600字”，希望能帮助到您。 有人问，幸福是什么？对啊，“幸福”这个感受得到却说不清楚的东西到底是什么？它又在哪里呢？ 幸福在这里，在我的这张生日照上。“乖女儿，今天是你的生日，你想吃什么？老爸给你做。”这句话，是爸爸在我每次生日时千篇一律却不会不耐烦的一句话。每到这时，也会有人和我说类似的话：“你爸爸怎么这么小气啊？都 ___。不像我爸，我生日的时候他给我买了名牌裙子呢！”我听到这样的话，每次都只是一笑而过，因为再多的金钱也比不上父母对我融到骨子里的爱。他们拿着父母一个鼠标就可以买来的生日礼物时的满足，怎能比得上我与父母围桌吃饭时的愉悦、欣喜呢？没有家人陪在身边、没有父母的祝福，这个生日怎么可能真正的幸福呢？这张生日照可是一张其乐融融的全家福啊。瞧，我们三个笑得多甜！原来，幸福是过生日时家人的陪伴！ 幸福，还在这里，在我可爱学校的操场上。“怎么了？没事吧？”同学们见到我晕倒了，赶紧围过来，急切地询问着。炎炎骄阳下的那缕清风，也比不上同学间纯洁的友情。这就是我团结友爱
的班集体！同学们围在我的身边，我被温馨的气息包围着。原来，幸福就是遇到困难时朋友关心的话语。 幸福，现在又融进一首首暖心的歌曲里。动人心弦的歌曲牵着我的心翩翩起舞。我的心化作一汪粼粼清泉，享受着无尽的舒适合安恬。幸福，原来也是这静谧宜人的时光。 幸福是什么？答案就在你心中，像蜂巢里的蜜，慢慢酝酿流溢。幸福在哪里？并不需要刻意寻找，因为它就在你的身边。 在这世界上，有一样无价的东西，那就是感情。人的感情多种多样，又欢乐、幸福，也有悲伤、难过。当人们感到幸福时会笑，会永远地牢记在心中，当人们感到难过时会哭、会发泄。不管是幸福还是难过，它们都是无价的，是人生中最不可缺少的'。 我们现在还只是初中生，没有高中生的学校住宿，也没有大学生的远离他乡去读书，但我们依旧是幸福的，虽然不会太深的感受到亲朋好友的幸福、快乐。 在任何城市，在任何地区，每当开学时期，火车站总会人山人海，他们大多数是去外地读书的学生以及他们的家长，火车站总是有着人们依依不舍的感情，还有疼爱自己、关爱自己的家人。远离
石油化工专业常用英语缩写
石油化工英语常用缩写(第一版)(https://www.wendangku.net/doc/6018855137.html,石油软件下载) 序号缩写英文中文 1 AC Air Conditioning 空气调节装置 2 AGO Atmospheric gas oil 常压瓦斯油 3 AML Approved Manufacturers' List 批准的厂商名单 4 APE Area Project Engineer 区域项目工程师 5 AR Atmospheric residue 常压渣油 6 ARDS Atmospheric residue desulfurization 常压渣油加氢脱硫 7 ASME American Society of Mechanical Engineers 美国机械工程师协会 8 BD Business Director 商务主任 9 BD Business Development 市场部 10 BEDP Basic Design Engineering Package 基础设计包 11 BFW Boiler feed water 锅炉给水 12 BL Battery limits 界区 13 BEDD Basic Engineering Design Data 基础工程设计数据 14 BM Bill of Material 材料表 15 BOD Basis of Design 设计基础 16 BOD Biological Oxygen Demand 化学需氧量 17 BP Boiling point 沸点 18 BS Bright stock 光亮油 19 BSI British Standards Institute 英国标准协会 20 BTEX Benzene, toluene, ethyl benzene, xylene 苯,甲苯,乙苯,二甲苯 21 BTU British thermal unit 英热单位 22 BTX Benzene, toluene, xylene 苯,甲苯,二甲苯 23 C Construction 施工 24 CAD Computer Aided Design 计算机辅助设计 25 CADD Computer Aided Design and Drafting 计算机辅助设计和绘图 26 CCR Conradson carbon residue 康氏残炭 27 CCR Continuous Catalyst Regeneration 催化剂连续再生 28 CDU Crude distillation unit 原油蒸馏装置 29 CGO Coker gas oil 焦化瓦斯油 30 CI Cetane index 十六烷指数 31 CL Center line 中心线 32 CM Construction Manager 施工经理 33 CN Conference Note 会议纪要 34 COD Chemical oxygen demand 化学需氧量 35 CPDP Chinese Preliminary Design Package 中国初步设计包 36 CPM Critical Path Method 关键路径法 37 CR Catalytic Reforming 催化重整 38 CS Carbon Steel 碳钢 39 CW Cooling Water 冷却水 40 FEED Front End Engineering Design 前期工程设计 41 GB GUO BIAO 国标 42 GCD Guaranteed Completion Date 保证完成日期
制造业工厂常用英文与缩写词汇大全
一:常用術語 Hon Hai 鴻海 CMM Component module move 機動元件整合 CEM Contract Manu faction service 合約委托代工 IBSC Internet Business Solution Center 國際互聯網應用中心 PCEG Personal Computer Enclosure group 個人電腦外設事業群（FOXTEQ）CCBG Connector& cable business group CPBG Competition business group ESBG Enterprise system business group 鴻富錦事業群 SABG system assembly business group 系統組裝事業群 NWE Net Work Enclosure NSE Network system enclosure NSG Network system group NFE Network flexible enclosure Foxcavity = HZ = Hong Zhun 鴻準 Stamping tool shop I 沖模一廠 Stamping tool shop II 沖模二廠 Prototype workshop 樣品中心 Steel factory 裁剪廠 PCE molding tooling workshop PCE塑模廠 Hua Nan test and measurement center 華南檢測中心 MPE mobile phone enclosure MPE MBE mobile phone and notebook enclosure 明塑厂 MGE Alloy magnesium alloy enclosure 鎂合金 Engineer standard 工標 Document center (database center)資料中心 Design Center 設計中心 Painting 烤漆(廠) Assembly組裝(廠) Stamping 沖壓(廠) Education and Training教育訓練 proposal improvement/creative suggestion提案改善 Technological exchange and study 技術交流研習會 Technology and Development Committee 技術發展委員會 BS Brain Storming 腦力激蕩 QCC Quality Control Circle 品質圈 PDCA Plan Do Check Action 計劃執行檢查總結 DCC delivery control center 交貨管制中心 3C Computer 電腦類產品 Consumer electronics 消費性電子產品 Communication 通訊類產品 Core value（核心价值） Love 愛心
幸福在心中的作文5篇
幸福在心中的作文5篇 幸福，时时刻刻围绕在你身旁，是母亲一声温柔的叮咛，幸福是父亲一次粗糙的抚摸。其实幸福就在每个人的心里，一直都存在着。下面，xx为大家整理关于幸福在我心中的文章，欢迎大家阅读。 作文一：幸福在我心中 今年五一劳动节，爸爸妈妈放弃了休息时间，陪我到宝应去参加围棋升段比赛。刚开始报名的时候，尽管我的实力还没有达到，但我的热情很高，我积极地向老师争取，最终老师答应了。 30日早上，我们5点半就起床，6点多出发，到宝应已经7点半了，还好，离比赛还有半小时。我的第一场比赛打的很顺手，轻轻松松地将对手拿下。从考场出来，我心情好极了，第一时间告诉爸妈我的战果，他们也为我高兴。不一会儿，其他考场我熟悉的同学也出来了，他们有输有赢，我因为自己的胜利，对他们的情况只是问问而已，并不放在心上。与他们玩的非常开心，差点忘记这次是来比赛的了。 第二场开始了，我坐进了赛场，还没有从刚才的玩乐中完全清醒过来，就听裁判老师说“可以开始了”，我心神不定的与对手摆起了棋子，他执黑，我执白，他放在这，我就紧跟在他后;他放那，我也毫不示弱，追着他放。他快，我
也不慢，就这样，两路棋子摆完，我们的速度也是很惊人的，外人看来，我们俩不像是下棋，而是在“拣豆子”，你一个，我一个。这一盘，就在我们的“拣豆子”游戏中飞快地结束了，后来听老师说只用了10分钟，比赛结果，我输，他赢。这下，我没有了第一盘的喜悦，但是，我还有的是机会，出来后，我又照样和同学在一起打打闹闹。 就这样，第一天，我赢一盘，输三盘。妈妈说，我是输在下棋太快，没有经过认真思考，就只赶着下棋子。我可不这样想，心里很不服气，我明明也思考了呀，为什么总是说我不动脑筋呢。不管了，先玩吧，明天还有三场呢，我不相信我不赢。 第二天，我又按着自己的方法，和对手15分钟就下完了第一场，结果，又被你猜中了，输。这下，我傻眼了，为什么我连输了四场呢?难道老师和爸妈的说法是对的吗?我真的没有认真思考吗?我没有看清棋盘上的局势吗?我太浮躁了吗?我在想着的时候，妈妈走过来，对我说：“儿子，这次我们只是来试试身手，妈妈对你的输赢并不太看重，但是，我最在意的你的下棋态度，这一点，你做的非常不好。希望下一场，你能够慢一点，哪怕只是下满半小时，我也看到你的进步了。”我经过好几次的失败打击之后，心情糟透了，听了妈妈说的话，我难过的眼泪都快要下来了。我答应妈妈，一定认真再认真，我就不信我不能赢。
石油行业英文缩写汇总--精选.doc
3DLO 3DHR-HR 3D long offset seismic survey 三维长偏移距野外资料采集 3D High resolution–high ???seismic survey三维高分辨－高密野外资料采集。 AAC = adjusted AC; ABI inclination at the drill bit AC ACN ADN AIT* A&S AHC ARC ARI acoustic 声波时差 =adjusted CN; Azimuthal neotron density Array Induction Imager Tool admistration&service Ascendant Hierarchical Clustering Induction Resistivity GR annulus pressure ingrated tool Azimuth resistivity imager方位电阻率成像测井仪 APD Elevation of Depth Reference (LMF) above Permanent Datum APWD ASI AVG: AVO apparatus whle drilling Array seismic imager 阵列地震成像仪 Average Amplitude Versus Offset(Amplitude variation with offset calibration) 振幅 -炮检距关系 AZI: BBC BGG: Azimuth (deg) Buy Back Contract Background Gas (%) BGP 物探局 BHFP bottomhole flowing pressure BHS :Borehole Status BHT :Bottom Hole Temperature BHTA BHTT 声波幅度 声波返回时间 BLWH Blue White BML below mud line BOP Blow out preventer BOP stack 防喷器组 BS Bit Size BSW basic?? saturation water(综合含水) CAL borehole diameter 井径 CAST 声波扫描成像测井仪 CBI Central Bank of Iran CBIL 井周声波成像 CBL CC CCAL CCL CCM CDF CDF Cement Bond Log correlation coefficient common core analysis 常规岩心分析 Casing Collar Locator Contractors Committee Meeting cumulative density function Calibrated Downhole Force
给材料作文
阅读下面的材料，根据要求作文。 1 21世纪，会带给我们些什么呢？面对新世纪的曙光，我们对新世纪有太多太多的渴望和憧憬，但也清楚地知道，不尽的未来带给我们的还有太多太多的未知以及什么都可能有的变数。 请以"新世纪，我的渴望和憧憬"为话题写一篇文章。 【要求】①立意自定；②文体不限；③题目自拟；④不少于800字。 【提示】本题属对象和时间的限制。写作时要注意"我"和"新世纪"，要写出自己的真情实感，要具有鲜明的时代感。 2 阅读下面一首短诗，根据要求作文。 散步的时候/ 我走直路/ 儿子却故意/ 把路走弯/ 我说/ 把路走直/ 就是捷径/ 儿子说/ 把路走弯/ 路就延长 请以"选择"为话题，写一篇抒发你对自己人生路的感受，或阐发你对人生路的看法的文章。【要求】①立意自定；②文体不限；③题目自拟；④不少于800字。 【提示】本题属范围的限制。作文选材范围是多方面的，如学生生活、社会生活、人生感悟、传统美德、哲理思辩等。本文内容一定是对"人生路"的感受或看法。 3 阅读下面的材料，根据要求作文。 人生有"四气"：奋发向上、百折不回的志气；铁面无私、令人敬畏的正气；披荆斩棘、舍生取义的勇气；求新求好、能做善做的才气。 请根据材料，以"人生的关键"为话题写一篇文章。 【要求】①立意自定；②文体不限；③题目自拟；④不少于800字。 【提示】本题属主旨的限制。文章主旨即为"四气"中的某一"气"，如：人生的关键是要有奋发向上、百折不回的志气。 4 阅读下面一则寓言，根据要求作文。 海滩上撒满了彩色的贝壳，一群孩子在拾着。一个孩子捡起一枚贝壳，随手又把它丢弃。他已经寻找了一个下午，始终没有找到自己心目中那枚最美、最稀罕的贝壳。夕阳西下，海与天连成一片深深的蓝色，他的伙伴们已经捡了满满一篮子贝壳，只有他仍然拖着沉重的脚步在海滩上寻找…… 请以寓言的寓意为话题写一篇文章。 【要求】①不得只改写、扩写材料；②文体不限；③题目自拟；④不少于800字。 【提示】本题属主旨的限制。这则寓言实际上讲的是人们对人生目标的两种态度：或执着追求崇高的理想，或脚踏实地从小事做起。 5 阅读下面的材料，根据要求作文。 宋朝大文豪苏轼读到王安石的《咏菊》"昨夜西风过园林，吹落黄花满地金"后，认为菊花并不落瓣，于是随后写道："秋花不比春花落，说与诗人仔细吟。"后来苏轼调任黄州团练副使，在重阳节后的一天步入菊园，只见满地铺金，枝上已无一朵菊花，到此才知，同为菊花竟也有落瓣与不落瓣之分。
生产制造英文缩写大全
膅EVT(Engineering Verification Test)工程验证测试阶段 膁DVT(Design Verification Test)设计验证测试阶段 艿DMT（Design Maturity Test）成熟度验证 腿MVT（Mass-Production Verification Test）量产验证测试 薃PVT(Production/Process Verification Test)生产/制程验证测试阶段膄MP(Mass Production)量产 莈工程师类: 芆PE: Product Engineer 产品工程师
莅Process Engineer 制程工程师 羃ME: Mechanical Engineer 机构工程师 莈IE：Industrial Engineer 工业工程师 蚇QE: Quality Engineer 品质工程师 肇SQESupplier Quality Engineer供货商质量工程师 蚂QC quality control 品质管理人员 蒈FQC final quality control 终点质量管理人员 肈IPQC in process quality control 制程中的质量管理人员蒅OQC output quality control 最终出货质量管理人员
蒁IQC incoming quality control 进料质量管理人员薈TQC total quality control 全面质量管理 葿POC passage quality control 段检人员 芇QA quality assurance 质量保证人员 蒄OQA output quality assurance 出货质量保证人员蚈QE quality engineering 品质工程人员 薆TE Test Engineer 测试工程师 蚄AE Automatic Engineer 自动化工程师