1.2 Database Systems

Transkript

BRNO UNIVERSITY OF TECHNOLOGY
FACULTY OF MECHANICAL ENGINEERING
Institute of Automation and Computer Science
DATABASE SYSTEMS
Doc. RNDr. Ing. Miloš Šeda, Ph.D.
BRNO 2005
© Miloš Šeda: Database Systems. Brno University of Technology, FME, November 2005
Contents
1. Theoretical Aspects of Data Processing ......................................................................... 3
1.1 Introduction ..................................................................................................................... 3
1.2 Database Systems ........................................................................................................... 3
1.2.1 Data Independence ....................................................................................................... 4
1.3. Data Models .................................................................................................................. 5
1.3.1. Integrity Constraints for Relationships ........................................................................ 7
1.3.2 Relational Data Model ................................................................................................. 8
1.3.3 Relational Algebra ....................................................................................................... 9
1.3.4 Relational Algebra as a Query Language .................................................................. 14
1.4 Database Design ........................................................................................................... 16
1.4.1 Functional Dependencies, Normal Forms .................................................................. 17
1.4.2 Functional Analysis ................................................................................................... 24
2. Structured Query Language (SQL) ............................................................................. 28
2.1 SELECT Query ............................................................................................................ 28
2.1.1 Aggregate Functions .................................................................................................. 30
2.1.2 SELECT with Subqueries ........................................................................................... 32
2.2 Union Query ................................................................................................................. 36
2.3 Crosstab Query ............................................................................................................. 36
2.4 Update (Action) Queries ............................................................................................... 37
2.5 Definition Queries ........................................................................................................ 38
2.6 Computing with NULL Values, NULL in SQL .............................................................. 40
3. Visual Basic for Applications (VBA) ............................................................................ 41
3.1 Definitions and Declarations.......................................................................................... 41
3.2 Control Structures.......................................................................................................... 43
3.2.1 Assignment Statements ............................................................................................... 43
3.2.2 Conditional Statements .............................................................................................. 43
3.2.3 Loop Statements ........................................................................................................ 44
3.2.4 Jump Statements ........................................................................................................ 45
3.2.5 With Statement ........................................................................................................... 45
3.2.6 Procedures and Functions ......................................................................................... 46
3.2.6.1 Parameters of Procedures and Functions ................................................................. 46
3.2.6.2 Call of Procedures and Functions ............................................................................ 47
3.3 Forms ........................................................................................................................... 48
3.3.1 Event Procedures in Forms......................................................................................... 48
3.3.2 References to Collection Elements in Visual Basic ...................................................... 49
3.4 Hierarchy of MS Access Objects .................................................................................. 53
3.5 Object RecordSet .......................................................................................................... 56
3.6 Calling SQL from VBA ................................................................................................ 64
4. Database Application ................................................................................................... 66
References ......................................................................................................................... 79
Terminology ...................................................................................................................... 81
2
1. Theoretical Aspects of Data Processing
1.1 Introduction
Information system functions:
• Selection of information,
• prognoses of development,
• planning,
• decision making,
• application in automation of engineering tasks,
• application in economic data processing (wages, invoices, stock records, etc.).
Information system interface:
• Batch processing,
• conversation with system.
Implementation of IS
60s-80s ... Cobol, PL/1 - file processing
Drawbacks of file processing:
• Programmes and data are interdependent.
• Data redundancy.
• Data inconsistency.
• Data incompatibility.
• Difficult data accessibility.
• Data isolation.
• Problem of data sharing.
• Problem of information security.
• Problem of data integrity.
1.2 Database Systems
•
•
•
Data structures are separated from application (user) programs.
Data access is possible only through DBS programs.
Multiuser access is enabled and data security is provided.
DB + DBMS = DBS
•
•
Data are not organised in separated files, but in a centrally processed data structure,
called database (DB)
Central database management, i.e. all programs are implemented by means of special
software, called Database Management System (DBMS).
DBMS
1. Tools for data definition
Data Definition Language (DDL)
CREATE, INDEX, …
3
2. Tools for algorithm description
Data Manipulation Language (DML)
INSERT, UPDATE, DELETE, SELECT, …
external
level
view of
user 1
view of
user 2
conceptual
level
logical
scheme
internal
level
physical
scheme
…
view of
user n
Fig. 1. Architecture of DBS
1.2.1 Data Independence
- modifications of data definitions on lower level have no impact on data definitions on
higher level
1. Physical independence - changes of the physical scheme without changes of logical
scheme and application programs.
2. Logical independence - changes of conceptual level of data description without changes in
application programs.
Forms of file organisation
−
−
−
−
−
−
Heap
Linked organisation
Sequential
Transforming
Index-sequential
B-trees
ad ) Index-sequential organisation
- data file & index file (index)
4
data file
No.
1
2
3
4
index
ID
75…
66…
80…
59…
name
Jan
Jiří
…
…
surname
Kos
Černý
…
…
place
Brno
…
…
…
street
Orlí
…
…
…
no
4
…
…
…
…
…
…
…
…
key
59…
66…
75…
80…
No.
4
2
1
3
1.3 Data Models
a) Relational data model (entities and relationships among them are described by relational
schemes and relations).
b) Hierarchical data model (relationships among entities are represented by tree-structures,
vertices represent entities, edges represent relationships between pairs of entities).
c) Network data model ((relationships are modelled by general graph structures; hierarchical
model is a special case of the network model)
E-R (Entity-Relational) conceptual model
E (Entity) – object of the real world
Example: “teacher Kos Petr, ID 650512/…”
Entity type - abstraction describing the type of objects,
given by a name and set of attributes
Example: TEACHER(surname, name, ID,...),
SUBJECT(code, name, …) [noun, substantive]
Attribute - property of entities (and relationships),
function assigning a value to entities and relationships
R (Relationship) - relationship of 2 or more entities
Example:
“teacher Kos Petr, ID 650512/…” “teaches” “the subject xyz …”
Relationship type
Example: TEACHES, SUPPLIES, …
[(mostly) verb]
MS Access
• Entity type,
relationship type,
table name
•
Attributes,
headers of the table in table Data list,
field names in table Design view
•
Entities (instances of objects of entity type),
relationships (instances of objects of relationship type),
table rows
E-R diagram and its graphical symbols
5
graphical symbol
1
M, N, …
shape
interpretation
rectangle
entity type
diamond
relationship type
oval
attribute
line
connection of symbols
number 1
single occurrence in relationship
letters M, N, multiple occurrence in relationship
…
Type E-R diagrams
SURNAME
NAME
NAME
ID
AUTHOR
DATE
ISBN
…
…
N
1
READER
LENT
BOOK
Fig. 2. E-R model with 1 : N relationship
SURNAME
NAME
YEAR
DUTIES UNDER
CONTRACT
ID
…
SEMESTER
…
CODE
M
TEACHER
NAME
TEACHES
N
Fig. 3. E-R model with M : N relationship
6
SUBJECT
1.3.1 Integrity Constraints for Relationships
1.
2.
3.
4.
Cardinality – 1:1 (one-to-one relationship), ), 1:N (one-to-many), M:N (many-to-many)
Membership
Min-max integrity constraint
Weak entity types, foreign key
Cardinality
1:1
1:N
M:N
Fig. 4. Relational cardinality, occurrence E-R diagram
Membership in relationship
- obligatory (complete)
- optional (partial)
Examples:
N
1
WARD
WORKS
DOCTOR
M
TEACHER
N
SUBJECT
TEACHES
(Optional subjects need not be opened)
M
SPORTSMAN
N
WON
7
COMPETITION
1
READER
N
LENT
BOOK
Min-max integrity constraint
Let the denotation R(E1, E2) represent the following diagram
R
E1
E2
and E:(min,max) denote minimal/maximal number of occurences of the entity E in the
relationship R.
Then
R ( E1: (1,1), E2 : (1,1) ) corresponds to
R ( E1: (1,1), E2 : (0,n) )
R ( E1: (0,1), E2 : (0,n) )
R ( E1: (0,m), E2 : (0,n) )
1:1
1: N
(0 or 1) : N
M :N
Example: Library system
BOOK-LOAN (READER : (0,5), COPY : (0,1) )
BOOK-RESERVATION (READER : (0,4), BOOK : (0,n) )
REGISTRATION (BOOK : (1,n), COPY : (1,1) )
n - more pieces,
REGISTRATION (BOOK : (0,n), COPY : (1,1) )
0 - book is not in the fund, e.g. lost book or loan from a foreign library
1.3.2 Relational Data Model
Definition 1.
Let Di, 1≤ i ≤ n be a system of nonempty sets, so called domains. Then each subset of
Cartesian product R ⊆ D1 × D2 × … × Dn is called a relation of degree n over domains
D1, D2, … ,Dn. Elements of R are ordered tuples (d1, d2, … ,dn), where di∈ Di, 1 ≤ i ≤ n.
A relational scheme is the expression of the form R(A1:D1, A2 :D2, … , An :Dn), where
Ai are attribute names. [shortened version: R(A1, A2, … , An).]
[The pair (Ai :Di) is called an attribute of the relation R.]
Note: Databases contain finite number of data
⇒ only finite relation are considered;
domains – data types (STRING, INTEGER, … )
8
Database relation can be represented as:
a)
matrix with m rows and n columns,
columns have additional denotations by names (attributes).
b) table,
each element of the relation corresponds with one row of the table,
there are no equal rows (relation = set),
ith column contains values only from the domain Di , column headers represent attributes.
Note:
mathematics – relation elements = ordered tuples
table representation – the order of columns can be changed
Example:
WORKERS
number
W1
W2
W3
D1
D2
D3
D4
surname
Starý
Novák
Kříž
name
Jan
Petr
Jiří
salary
17000
14000
21000
set of strings Wn , n - natural number
set of surnames (STRING)
set of names (STRING)
set of nonnegative integers (LONG INTEGER)
1.3.3 Relational Algebra
Besides the definition of relations as a tool for modelling databases, the relational model must
also contain a set of operations with databases.
There are two basic tools for manipulations with relations:
n
relational algebra and
n
relational calculus.
Operations of the relational algebra
(1) The union of relations R and S of the same degree (and defined on the same domains) is
denoted by R ∪ S and defined as follows:
R∪S={t|t∈R ∨ t∈S}
(2) The difference of relations R and S is denoted by R − S and defined as follows:
R−S={t|t∈R ∧ t∉S}
9
Example:
R
S
A
a
d
c
B
1
2
1
R∪S
A
a
d
c
b
B
1
2
1
3
A
b
c
B
3
1
R−S
A
a
d
B
1
2
⇒
Tab. 1. Union and difference
(3) The Cartesian product of a relation R of degree n and a relation S of degree m is denoted
by R × S and defined as follows:
R × S = { rs | r ∈ R ∧ s ∈ S }, where rs = (r1, r2 , … , rn, s1, s2, … , sm)
Example:
R
S
A
a
b
B
1
1
C
x
y
R×S
A
a
a
b
b
B
1
1
1
1
C
x
x
y
y
D
2
2
D
2
2
2
2
E
a
b
⇒
E
a
b
a
b
Tab. 2. Cartesian product
(4) The projection of a relation R of degree n on attributes A = (i1, i2, … im), where 1 ≤ ij ≤ n,
ij ≠ ik for j ≠ k, is a list of indices of different components of the relation R (columns of
the corresponding table or names of attributes, respectively), it is denoted by R[A] and
defined as follows:
R[A] = { r[A] | r∈R }, where r[A] = (ri1, ri2, … , rim for r∈R
(The projection serves to a selection of table columns.)
10
Example:
R
A
a
b
B
1
2
R[A]
A
a
b
C
x
x
⇒
R[C]
C
x
R[A,C]
A
a
b
C
x
x
Tab. 3. Projection
(5) Selection (or restriction):
Let R be a relation, ϕ be a logical formula (it can contain logical operators ∧ ∨ ¬). The
selection (restriction) from the relation R by ϕ is denoted by R[ϕ] and defined as
follows:
R[ϕ] = {r | r∈R ∧ ϕ (r)}
(The selection operation serves to a selection of table rows.)
Example:
R
A
1
3
2
1
R[A>2]
A
3
B
a
b
a
c
B
b
C
2
2
2
1
C
2
⇒
R[A≤C]
A
1
2
1
B
a
a
c
C
2
2
1
R[(A>C)∨ (B=”c”)]
A
B
C
3
b
2
1
c
1
Tab. 4. Selection
Note:
(1)-(5) represent basic relational algebra operations, the further operations can be expressed
by (1)-(5).
(6) The intersection of relations R and S is denoted by R ∩ S and defined as follows:
R∩S={t|t∈R ∧ t∈S}
11
Example:
R
S
A
a
d
c
B
1
2
1
R∩S
A
c
B
1
A
b
c
B
3
1
⇒
Tab. 5. Intersection
(7) Θ-join
Let R be a relation of degree m, i∈{1,2, … ,m},
S be a relation of degree n, j∈{1,2, … ,n},
Θ∈{<, ≤, = ≥, >, ≠}
The Θ-join of relations R and S by Θ over the ith attribute of the relation R and jth
attribute of the relation S is denoted R[i Θ j]S and defined as follows:
R[i Θ j]S = {rs | r ∈ R ∧ s ∈ S ∧ r[i] Θ s[j]}
(The Θ-join is the Cartesian product restricted by a condition Θ, i.e. the result contains
only the rows that satisfy Θ.)
Example:
R
S
A
a
b
b
B
1
1
2
C
1
2
2
R [B = D] S
A
B
a
1
a
1
b
2
C
1
2
2
D
1
2
3
D
1
1
2
E
x
y
z
E
x
x
y
12
⇒
R [C > D] S
A
B
a
1
b
2
C
2
2
D
1
1
E
x
x
R [C < D] S
A
B
a
1
a
1
a
1
b
2
C
1
1
2
2
D
2
3
3
3
E
y
z
z
z
Tab. 6. Θ-join
Note:
If Θ is the equality condition, then the resulting join will contain two same columns.
Therefore the following modification of the join operation is defined:
R[i∗j]S = (R[i = j]S) [1,2, … ,m+j-1, m+j+1, …, m+n]
- one of the same columns is omitted.
(8) Natural join of relations R and S is denoted by R[∗]S.
This join operation selects from the Cartesian product R × S those records, that have on
the common columns the same values; redundant columns are from the resulting join
omitted.
(9) Division.
Let R be a relation of degree m and S be a relation of degree n.
Let A = (i1, i2, … ,ik), ij ∈{1,2, … ,m}, j = 1, … ,k, ij ≠ ik pro j ≠ k,
B = (g1, g2, … ,gt), gj ∈{1,2, … ,n}, j = 1, … ,t, gj ≠ gk pro j ≠ k,
be lists of selected attributes of R and S, respectively (for simplicity, the attributes are
denoted by natural numbers).
Let us denote Ā = (j1, j2, … , jm−k), where jp ∈ {1,2, … , m}−A for p =1,2, … , m−k,
jp< jk for p< k (i.e. Ā are attributes of R, that were not selected into the list A).
Let us define for r∈R a set imR (r[Ā]), (image set), that contains all complements of r[Ā],
which in product with r[Ā] create an element of the relation R, thus
imR (r[Ā]) = {y | r[Ā] y ∈ R[Ā, A] }.
The division of a relation R over A by a relation S over B is denoted by R[A : B]S and
defined as follows:
R[A : B]S = {r[Ā] | r∈R ∧ (S[B] ⊆ imR (r[Ā])}.
It can be proved that the following equation is satisfied
R[A : B]S = R[Ā] − ((R[Ā] × S[B]) − R[Ā, A] ) [1,2, … ,m−k]
13
Example: Image set
R
D1
1
2
1
2
3
1
2
D2
a
a
b
c
a
b
a
D3
x
y
x
y
x
y
x
D4
f
g
f
h
f
f
h
D5
2
3
2
3
1
2
3
Nechť A ={D3, D2, D4}, pak Ā = {D1, D5}. If r = (1, a, x, f, 2), then r[A] = (x, a, f),
r[Ā] = (1,2), and thus imR(r[Ā]) = imR(1,2) = {(x, a, f), (x, b, f), (y, b, f)}.
Note:
Minimal set of operations of the relational algebra:
{ union, Cartesian product, difference, selection, projection }
i) Θ-join can be defined by means of the Cartesian product and selection,
ii) natural join by means of the Cartesian product, selection and projection,
iii) intersection can be defined as follows:
* R ∩ S = R ∪ S − (R − S) − (S − R),
* R ∩ S = R − (R − S),
* R ∩ S = S − (S − R).
S
R
R−S
R∩S
S−R
1.3.4 Relational Algebra as a Query Language
Example:
Let us consider the following relations:
CANDIDATES(ID, name, surname, town, street, No, ZIP-code)
LANGUAGUES(code, language-name)
KNOWLEDGE(ID, code, knowledge-degree).
14
where knowledge-degree ∈ {“beginner”, “advanced”, “excellent”}
Define queries for solving the following tasks:
(Q1)
All data about all candidates
Q : = CANDIDATES
(Q2)
IDs, names and surnames of candidates from Brno.
Q : = (CANDIDATES[town="Brno"] ) [ID, name, surname]
(Q3)
Names and surnames of candidates with excellent knowledge
of English.
Q : = {CANDIDATES [∗] (KNOWLEDGE[code="Eng" AND
knowledge-degree= "excellent"])} [name,surname]
(Q4) Languages, in which the candidate specified by his ID, is at least advanced.
Q : = { (KNOWLEDGE [ID=given-ID AND
(knowledge-degree = "advanced" OR knowledge-degree = "excellent")] )
[∗] LANGUAGES} [language-name]
(Q5) Candidates, who are excellent at least in one language and its name.
Q : = {CANDIDATES [∗] (KNOWLEDGE [knowledge-degree ="excellent"] ) }
[name,surname,code]
(Q6) Candidates, who speak only English.
those, who speak only English =
those, who speak English − those, who speak another language
Q : ={ (KNOWLEDGE [code="Eng"] ) [ID] − (KNOWLEDGE [code<>"Eng"]) [ID] }
[∗] (CANDIDATES[ID, name, surname] )
(Q7) Candidates, who speak no foreign language
those, who speak no foreign language =
all − those, who speak at least 1 foreign language
Q : = (CANDIDATES [ID] − KNOWLEDGE [ID])
[∗] (CANDIDATES[ID, name, surname] )
(Q8) Candidates, who have al least basic knowledge of all world languages.
Q1: all candidates speak all world languages = Cartesian product
CANDIDATES [ID] × LANGUAGES[code]
Q2: non-existing knowledge = all speak all − registered knowledge
Q3: those, who speak all = those, who speak at least one language −
− those, who do not speak at least one language
Q1 : = CANDIDATES [rodné-č] × LANGUAGES[code]
Q2 : = Q1 − KNOWLEDGE [ID, code]
Q3 : = KNOWLEDGE [ID] − Q2 [ID]
Q : = Q3 [∗] (CANDIDATES [ID, name, surname] )
It can also be solved by means of the division operation
Q1 : = KNOWLEDGE [{A1, A2, … } − { ID } : kód] LANGUAGES
15
Q : = Q1 [∗] ( CANDIDATES [ID, name, surname] )
1.4 Database Design
Motivation examples:
PERSONS
ID
1
2
3
4
name
Jan
Petr
Jiří
Milan
surname
Kos
Růžička
Sova
Konečný
address
Brno, Orlí 4, 602 00
Praha, Pod vodárenskou věží 2, 182 07
Ústí nad Labem, Masarykovo nám. 4, …
Brno, Lerchova 22, 602 00
Instead of the “set” attribute address is better to define atomic attributes town, street, No,
ZIP_code. Then we get the following relational scheme
PERSONS(ID, name, surname, town, street, No, ZIP_code).
Definition:
A relational scheme R(A1, … , An) is in the first normal form (1NF) if attributes A1, … , An
are atomic, i.e. their domains are sets of simple values, e.g. sets of numbers (INTEGER,
REAL, ...), characters (CHAR), words in an alphabet (≈ STRING), etc.
Example:
PERSONS
IDdept department
1
design_office
2
drawing _office
3
accounting_dept
4
…
head
Novák
Růžička
Konečná
…
workers
Novotný, Navrátil, Sedláček, Janíček
Karas, Kos, Sova
Nová, Stará, Jarošová, …
…
This relational scheme can be transformed into the 1NF, e.g., in this way:
PERSONS
IDdept department
head
workers
1
design_office
Novák
Novotný
1
design_office
Novák
Navrátil
1
design_office
Novák
Sedláček
1
design_office
Novák
Janíček
2
drawing _office Růžička
Karas
2
Kos
2
Sova
3
accounting_dept Konečná
Nová
3
Stará
3
Jarošová
…
…
…
…
However, this transformation is unsuitable, because it contains these drawbacks:
16
1. Redundancy.
Information about each department is repeated so many times as the number of its workers
is.
2. Risk of inconsistency when modifications are performed.
From the redundancy more complicated updates result. If a new head is installed, the head
of the accounting department changes her name, or one of the departments changes its
number, then this datum must be changed for all workers of the corresponding
department. If this correction is not done completely, then the data will become
inconsistent (one department has two heads or two different numbers, respectively).
3. Insertion anomaly.
No information about an established department can be inserted if it is has no workers.
4. Deletion anomaly.
If all workers of a department leave it, then their deletion in the table causes the loss of
connecting information about the department, that is not desirable.
⇒ usually it is not suitable to use only one table and it is necessary to decompose the original
table into several tables in 1NF, however, they must contain some connecting data to preserve
all information.
In our example, we can decompose the original relational scheme EMPLOYEES into 3
relational schemes
WORKER(IDw, name, surname, IDdep)
DEPARTMENT(IDdep, dept_name)
HEAD(ID, IDdep)
1.4.1 Functional Dependencies, Normal Forms
Definition:
Let X, Y be subsets of a set of attributes A. Then we say that Y functionally depends on X (or
X functionally determines Y) and denote X → Y if for each possible current relation R is
satisfied that if two elements of R have equal values of attributes (or sets of attributes) X, then
they also have the same values of attributes (or sets of attributes) Y. More formally:
X → Y on R(A) ⇔ ∀ r1, r2 ∈ R, (r1.X = r2.X) ⇒ (r1.Y = r2.Y) n
Note:
A functional dependency is defined for all possible instances of the relation, and thus it is not
possible to decide on a functional dependency from one instance. On the other hand, from the
only one relation it is possible to show the functional independence between some attributes
or sets of attributes, respectively.
Logical implications
Definition:
Let F be a set of functional dependencies, then we say that F logically implies a dependency
X → Y (or X → Y is functional dependency (logically) derivable from F), if this dependency
is satisfied in all relations, in which the dependencies from F are satisfied. The set of all
functional dependencies derivable from F is called a closure of F and denote it F+. n
Note:
17
With respect to the infinity number of such relations, F+ cannot be calculated from this
definition. Therefore we need another mechanism for checking whether the given dependency
X → Y is in F+ or not.
Inference rules
- equivalent tool for a calculation of F+, or for a determination if a given dependency X → Y
is in F+ or not.
Rules must satisfy the following properties
(i) soundness, by means of these rules from F can be derived only dependencies from F+;
(ii) completeness, rules allow to derive all functional dependencies from F+ and
(iii) independence, if a rule is removed, then the completeness property will be lost.
Armstrong’s axioms
- inference rules of functional dependencies in the classical relational database theory.
Let X, Y, Z are subsets of a set of attributes A. Then it holds:
A1: Inclusion rule.
If Y ⊆ X, then X → Y .
A2: Augmentation rule.
If X → Y, then XZ → YZ (XZ stands for X ∪ Z).
A3: Transitivity rule.
If X → Y and Y → Z, then X → Z.
From Armstrong’s axioms further useful rules for inference of functional dependencies can be
derived (W in the last of them denotes a subset of A):
P1:
P2:
P3:
Union rule.
If X → Y and X → Z , then X → YZ.
Decomposition rule.
If X → YZ , then X → Y and X → Z.
Pseudo-transitivity rule.
If X → Y and YW → Z, then XW → Z.
Proof.
[P1] From the first assumption X → Y of Rule P1, we get by A2 that XZ → YZ. Similarly
from the second assumption X → Z of Rule P1 we get by A2 that XX → XZ, and thus
X → XZ. Finally from X → XZ and XZ → YZ we get by A3 that X → YZ.
[P2] From Rule A1 implies YZ → Y and YZ → Z. From these facts and from the assumption
X → YZ of Rule P2, applying Rule A3, we get X → Y a X → Z.
[P3] From the first assumption X → Y of Rule P3 we get, applying Rule A2, the dependency
XW → YW, which with further assumption YW → Z of Rule P3 implies by Rule A3 the
functional dependence XW → Z, what we wanted to prove.
Algorithm for computing transitive closure F +
Input:
F
… set of fuzzy functional dependencies for the set of attributes A
of a relational scheme R(A), where |F|=m and |A|=n,
18
f=X→Y
… X⊆A, Y∈A.
Outputs: X+
… transitive closure of X with respect to F,
membership … True, if f ∈F+ ; False, otherwise.
Data structures:
LS[1: m],
RS[1: m]
Done
… arrays of attributes from left/right sides of dependencies
from F,
… Boolean variable.
begin X : = X;
repeat Done : = True;
for i : = 1 to m do
begin if (LS[i] → RS[i]) and (LS[i]⊆ X+) and (not (RS[i]⊆X+))
then begin X+ : = X+ ∪ RS[i];
Done : = False
end
end
until Done;
membership : = (Y∈X+)
end
+
Relational scheme keys
Definition K1: (using functional dependency)
Given a relational scheme R(A) and K ⊆ A, then K is the key of R, if it satisfies the following
properties:
(V1) K→ A
(Uniqueness)
(V2) There is no K' ⊂ K so that K' → A.
(Nonredundancy)
Definition K2: (using closure)
Given a relational scheme R(A) and K ⊆ A, then K is the key of R, if it satisfies the following
properties:
(V1') K→ A ∈ F+.
(Uniqueness)
+
(V2') For each K' ⊂ K it is satisfied K' → A ∉ F . (Nonredundancy)
Remarks:
(1) Each relation has a key (in the worst case it can be given by A)
(2) A relation can contain more keys, e.g. in the table
PERSONS(ID, name, surname, passportNo, …).
the key can be ID or passportNo.
One of the keys is determined as a primary key.
(As a primary key is usually selected the key which is minimal in some sense (one
segment))
(3) An attribute which occurs at least in one of the keys, is called a key attribute. Attributes
that are not included in keys, are called nonkey attributes.
19
Special types of functional dependencies
Definition:
Given a relational scheme R(A), where R is a relation and A is a set of attributes and X, Y are
subsets of A, then we say that:
(i) Y fully functionally depends on X, X→Y, if there is no X', X' ⊆ X, X'≠∅ so that X' → Y.
(ii) Y partially functionally depends on X, X → Y, if there is X', X'⊂ X, X'≠∅ so that X'→ Y. n
Note:
Using (i), the property of nonredundancy in the definition of key can be expressed as follows:
(V2'') A fully functionally depends on XK.
Definition:
Let X, Y be subsets of a set of attributes A, C be a single attribute, which is neither in X nor in
Y. If X→Y, Y→ C are functional dependencies, and Y→X is not a functional dependency, then
we say that C transitively functionally depends on X. n
Normal forms of relations (2NF, 3NF, BCNF)
Definition:
A relational scheme is in:
(2) the 2nd normal form (2NF), if it is in the 1NF and contains no partial functional
dependencies of nonkey attributes on a key;
(3) the 3rd normal form (3NF), if it is in the 2NF and each nonkey attribute is not
transitively dependent on keys;
(3½) Boyce-Codd normal form (BCNF), if it is in the 3NF and contains no transitive
dependency of key attributes (of one key) on (the other) key.
Note:
There is also the 4th normal form (4NF), that refers to a multivalued functional dependency.
Multivalued functional dependency
Definition:
Denote C(b) a set of C-values (i.e. a set of values of the attribute C) assigned in a certain
moment to B-value b. Let X, Y, Z be subsets of a set of attributes A such that Z = A − X − Y.
Then Y multidepends on X, if for each XZ-value xz, it is satisfied Y(xz) = Y(x).
This fact is called multidependency of Y on X and is denoted by X→→Y.
If Z is the empty set (i.e. XY includes all attributes), then the multidependency X→→Y is
trivial.
Note:
Therefore the attribute Y in R(A) multidepends on the attribute X, if it is satisfied that each
value of attribute X determines the set of values of the attribute Y and this set is independent
on the values of the other attributes in R(A).
20
Definition:
A relational scheme R(A) is in the 4th normal form (4NF), if in the case when it contains a
multivalued dependency X →→ Y, where not(Y⊆X) and XY does not contain all attributes A,
then X also contains a key of the relation R.
Note:
R(A) is in the 4NF if for each multivalued dependency X→→Y is satisfied at least one of the
two conditions:
(1) Multidependency is not trivial
(2) X includes a key of R(A)
0NF
1NF
2NF
3NF
BCNF
4NF
Fig. 5. Hierarchy of normal forms
Partial functional dependencies (FDs), transitive FDs a multivalued FDs cause all problems
mentioned above (the risk of inconsistency when modifications are performed, insertion and
deletion anomalies.
Example: [ 1NF ⇒ 2 NF ]
THEATRE-PROGRAM(theatre, drama, director, address, date)
It is not in the 2NF, because it contains partial functional dependencies:
theatre → address,
{drama, theatre} → director
Decomposition
THEATRE (theatre, address)
SCHEDULE(theatre, drama, date)
DIRECTOR(drama, theatre, director)
Example: [ 1NF ⇒ 3 NF ]
HOSPITALIZATION(patient-ID, patient-name, patient-surname,
ID_health-insurance-company, health-insurance-company,
date, time, doctor, department, diagnosis)
21
key = {patient-ID, hospitalization-date, hospitalization-time}
functional dependencies:
key → doctor, key → department, key → diagnosis.
patient-ID → patient-name, patient-ID → patient-surname,
patient-ID → ID_health-insurance-company →
→ health-insurance-company,
(full FD)
(partial FD)
(transitive FD)
Deccmposition:
PACIENT(patient-ID, patient-name, patient-surname)
DOCTOR(doctor-ID, doctor-name, doctor-surname)
DEPARTMENT(department-ID, department-name)
DIAGNOSIS(diagnosis-ID, description)
HEALTH-INSURANCE(ID_health-insurance-company, health-insurance-company)
HOSPITALIZATION(patient-ID, hospitalization-date, hospitalization-time,
doctor-ID, department-ID, diagnosis-ID)
INSURANCE(patient-ID, ID_health-insurance-company)
Note:
If we allow that patients can change their health insurance companies, then the functional
dependency patient-ID → ID_health-insurance-company is not satisfied and therefore it is
necessary during each hospitalization to register patient’s current health insurance company.
⇓
Decomposition:
PACIENT(patient-ID, patient-name, patient-surname)
DOCTOR(doctor-ID, doctor-name, doctor-surname)
DEPARTMENT(department-ID, department-name)
DIAGNOSIS(diagnosis-ID, description)
HEALTH-INSURANCE(ID_health-insurance-company, health-insurance-company)
HOSPITALIZATION(patient-ID, hospitalization-date, hospitalization-time,
doctor-ID, department-ID, diagnosis-ID, ID_health-insurance-company)
Example: [ 3NF ⇒ BCNF ]
DIRECTORY(town, street, ZIP-code)
key 1: {town, street}
key 2: {street, ZIP-code}
This relational scheme has no nonkey attribute, it is (trivially) in 3NF, but it is not in BCNF,
because it contains transitive dependency of key attribute town on the key {town,street}
{town, street} → ZIP-code → town
• Redundancy - town is repeated with its each street.
• Risk of inconsistency – e.g. when name is changed (Gottwaldov/Zlín etc.)
• Insertion anomaly – it is not possible to register a town with its ZIP-code if we do not
know at least one from its streets
Decomposition into 2 schemes:
STREET-LIST(street, ZIP-code), TOWN-LIST(ZIP-code, town)
22
Example: [ … ⇒ 4NF ]
EMPLOYEE(name, school, language)
name
Kos
Kos
Kos
Kos
Kos
Kos
Kos
school
basic
basic
high
high
university
university
university
language
Czech
English
Czech
English
Czech
English
German
It contains two multivalued functional dependencies name →→ school and name →→
language,
⇓
decomposition into 2 schemes:
S1(name, school), S2(name, language),
now in each scheme only one multivalued functional dependency is contained (1:N).
Note:
Decompositions must be lossless and preserve functional dependencies.
Definition:
Let R(A) be a relational scheme and ρ ={R1(A1), R2(A2)} be its decomposition and F be a set
of functional dependencies. We say that the decomposition is lossless with respect to F, if for
each relation R(A) satisfying F is:
R = R1(A1) [∗] R2(A2).
Theorem (decomposition theorem):
If in R(A1, A2, A3) a functional dependency A1 → A2 is satisfied, then R can be decomposed
without loss of information into projections R1(A1, A2) and R2(A1, A3).
Theorem: Let ρ ={R(A1), R2(A2)} be a decomposition of a relational scheme R(A) and F be a
set of functional dependencies. Then the decomposition ρ is lossless with respect to F if and
only if:
(A1 ∩ A2) → A1 − A2 or (A1 ∩ A2) → A2 − A1.
Example:
TEACHERS(name, institute, subject, contract)
F = {name → institute, {name, subject} → contract}
Decomposition:
ρ = { TEACH(name, institute), TE-SUB(name, subject, contract) }
{name, institute} ∩ {name, subject, contract} = {name}
23
{name, institute} − {name, subject, contract} = {institute}
From the previous theorem we get that this decomposition is lossless.
Example:
BOOK-ORDERS (orderNo, date, total-price,
customer-name, customer-surname, …,
shopNo, shop-place, … ,
book-title1, author1-1, author1-2, … , author1-5, publisher1, price1, … ,
book-title2, author2-1, author2-2, … , author2-5, publisher2, price2, … ,
…
book-title20, author20-1, author20-2, … , author20-5, publisher20, price20, … , )
Among entity types customer, order, shop, book, author there are the following relationships:
customer - order 1 : N
order - book
M : N ⇒ 1 : N, intersection table, N : 1
book - author
M : N ⇒ 1 : N, intersection table, N : 1
shop - order
1:N
CUSTOMER
IDcust
surname
name
…
ORDER
1
∞
∞
ordNo
IDcust
date
shopNo
…
SHOP
1
1
∞
DETAIL
ordNo
ISBN
count
tax
BOOK
1
1
∞
BOOK-AUTHOR
∞
shopNo
town
street
…
ISBN
IDauthor
index
∞
ISBN
title
year
publisher
price
…
AUTHOR
1
IDauthor
surname
name
e-mail
…
Note: 1:N is in MS Access denoted by 1:∞; primary key = blue background; foreign key =
grey background.
Reference integrity ≈ relationship between the primary key of the first relation and the foreign
key of the second relation.
1.4.2 Functional Analysis
- modelling of activities that concern with given application
24
function - verb in imperative mood
WHAT must be done,
not WHO, WHERE, WHEN and HOW
• on organisation level = working function,
• on conceptual level = process,
• on programme level = programme, procedure, transaction.
•
•
•
Hierarchy of functions
Event modelling
Data flow diagrams (Yourdon, DeMarco, …)
Hierarchy of functions
- functional structure diagrams (FSD)
F1
F1.1
F1.1.1
F1.1.2
F1.2
F1.2.1
F1.3
F1.3.1
F1.3.2
F1.3.3
Event in hierarchy of functions
works as a trigger
book a ticket by requirements
summarise requirements
for booking
Customer enters the
booking office
find free tickets
by requirements
make a reservation
Data Flow Diagrams (DFDs)
consist of 4 components:
1. processes - represent activities, one process can cover more functions
2. data flows - represent a data exchange among processes
3. data stores - locations, where data are saved (e.g. database, file, card file, paper sheet)
4. interface - represents external users that use data flows or data stores
25
Symbols in data flow diagrams
Yourdon DeMarco
Processes
process
name
process
name
Gane & Sarson
1
process
name
flow name
Data flows
Data stores
(memories)
store
name
store
name
Interface
(terminators)
inerface
name
inerface
name
kind and number of
memory
store
D1
name
inerface
name
Rules for DFD design
•
DFD must not contain:
o “black holes”, i.e. processes, into which data only enter
o “selfgenerating processes”, i.e. processes, which have only outputs
o data flows and processes with no description
•
Name of a date flow have to
o enable to understand the meaning of DFD and simplify communication
between user and solver
o represent the flow structure
Example:
DFD for withdrawal of money from account (DeMarco).
26
checked
statements
withdrawal
requirement
client
update
account
solvency
checking
updated
account
state of
account
accounts
confirmed
paper
archive of account
operations
Software engineering
•
Methodology – summary of processes and methods that define WHAT, WHO and
WHEN should be done during design, implementation and control of information
system.
Yourdon Structured Method, CASE Method fy Oracle, SSADM (Structured System
Analysis and Design Method), ...
•
Method - procedure or technique that defines WHAT is necessary to do in a given
project phase (date model, functional model, modules, definition of requirements,
testing, …).
Yourdon Structured Analysis/Structured Design, Jackson System Development, …
•
Technique - way, HOW to create this what a method recommends,
e.g. for the date model to use Chen’s ERA model, functional analysis should be done
by TopDown strategy, ...
•
Tool - BY WHAT we realize the technique, by what we express results,
e.g. data flow diagram (DFD), CASE (Computer Aided System/ Software Engineering),
...
27
2. Structured Query Language (SQL)
2.1 SELECT Query
SELECT [ALL | DISTINCT | DISTINCTROW | [TOP n [PERCENT]]]
{* | table.* | [table.] field1 [AS alias1]
[,table.] field2 [AS alias2]
[,...] }
FROM {1table1 [AS alias1t] |
2
select-query1 [AS alias1d] |
3
=1|2} [LEFT | RIGHT | INNER] JOIN
table2 [AS alias2t] ON join-condition
[IN external-database] }
[,{...}]
[WHERE search-condition]
[GROUP BY aggregate-key]
[HAVING search-condition-of-groups]
[ORDER BY { column-name | column-number [ASC | DESC] }
[,{...}]
[WITH OWNERACCESS OPTION]
join-condition
•
table1.field1{= |<> | < | <= | > | >= } table2.field2
search-condition
•
expression1 {= |<> | < | <= | > | >= } expression2
•
expression [NOT] BETWEEN bottom AND top
•
expression [NOT] IN set-of-values
•
expression [NOT] LIKE pattern-string
•
expression {= |<> | < | <= | > | >= } ALL (subquery)
•
expression {= |<> | < | <= | > | >= } ANY | SOME (subquery)
•
expression [NOT] IN (subquery)
•
[NOT] EXISTS (subquery)
Examples:
name LIKE "K*"
name LIKE "J?rka"
name LIKE "P[A-F]###"
name IN ("Jan","Jiří","Pavel")
name IN ([ersons].[name])
Note:
The expression ... EXISTS (SELECT ∗ ... ) is evaluated as true if the set of values in
brackets is nonempty.
28
Note:
In lists of output information not only the table fields but also more complex expressions can
be used.
Example:
PERSONS(birth-certificate-number, name, surname, ...)
PRACTICE(birth-certificate-number, organisation, date-of-accession, date-of-termination, ...)
Find a list of persons, their practice in registered organisations with the length of practice and
display them in the alphabetic order.
SELECT DISTINCTROW persons.surname, person.name, practice.organisation,
Val(Format(Iif(IsNull(practice.date-of-termination),
Date() − practice.date-of-accession,
practice.date-of-termination − practice.date-of-accession),
"yy")) AS „total number of years"
FROM persons LEFT JOIN practice ON persons.birthNo = practice.birthNo
ORDER BY persons.surname, persons.name
Note:
If in the clause FROM more tables without join and search conditions (in clauses JOIN and
WHERE, respectively) are mentioned then the query result is given by the Cartesian product
of these tables. This is possible to use in special situations, see the following example.
Example:
CHESS(playerID, name, surname)
The task is to generate the play list (all pairs).
SELECT chess.name, chess.surname, ch2.name, ch2.surname
FROM chess, chess AS ch2
The Cartesian product inside one table – the table is opened twice, second time with an alias.
This solution contains an error, it generates also pairs where both members are the same.
CHESS(playerID, name, surname)
•
one round play system
WHERE chess.playerID < ch2.playerID
•
two round play system
WHERE chess.playerID <> ch2.playerID
29
Note:
SELECT ∗
FROM Tab1,Tab2
WHERE Tab1.ID = Tab2.ID
by MS Access is processed in the same way as
SELECT ∗
FROM Tab1 INNER JOIN Tab2 ON Tab1.ID = Tab2.ID
Example:
DEPARTMENTS(deptID, dept-name)
WORKERS(birth-certificate-number, name, surname, deptNo)
1. INNER JOIN – combines only those records from given tables that satisfy the join
condition
2. LEFT JOIN – selects all records from the table DEPARTMENTS and only those records
from the table WORKERS in which joined fields are equal
(e.g. it also includes a new department without workers)
3. RIGHT JOIN – selects all records from the table WORKERS and only those records
from the table DEPARTMENTS in which joined fields are equal
(e.g. it also includes external workers that are not assigned to any department).
2.1.1 Aggregate Functions
aggregate function
COUNT(*)
meaning
number of records including those containing
Null values
number of records, records with Null values
of the field are not counted
arithmetic average
sum
minimal value
maximal value
standard deviation of the basic file of
numerical expressions
estimate of the standard deviation from
selected values
variance of the basic file of numerical
expressions
estimate of the variance from selected values
COUNT(field)
AVG(expression)
SUM(expression)
MIN(expression)
MAX(expression)
STDEV(expression)
STDEVP(expression)
VAR(expression)
VARP(expression)
30
Example:
OPTIONAL-SUBJECTS(student, subject-name, year, semester, ...)
The goal is to list the subjects that were selected by 10 or more students and display them in
the descending order by the number of students.
SELECT subject-name, COUNT(subject-name)
FROM optional-subjects
GROUP BY subject-name
HAVING COUNT(subject-name) >=10
ORDER BY 2 DESC
Example (Multisegment aggregate key):
Consider a relation scheme
SCHOOL(teacherID, name, surname, institute, function, ...).
Determine a list of institutes and number of professors, associate professors and senior
lecturers of these institutes.
SELECT institute, function, COUNT() AS number
FROM school
GROUP BY institute, function
It results in:
institute
Mathematics
Physics
function
professor
associate professor
senior lecturer
professor
associate professor
senior lecturer
…
Note: The aggregation order is substantial.
SCHOOL(teacherID, name, surname, institute, function, ...).
The following query
SELECT function, institute COUNT() AS number
FROM school
GROUP BY function, institute
returns the different result than the previous query as follows:
31
number
2
6
17
3
4
11
function
professor
associate professor
senior lecturer
funkce,
Mathematics
Physics
…
Mathematics
Physics
…
Mathematics
Physics
…
počet
2
3
…
6
4
…
17
11
…
2.1.2 SELECT with Subqueries
Example
FIRM1(birth-certificate-number, name, surname, salary, function, ... )
All workers from FIRM1 who have higher salaries than all workers from FIRM2.
SELECT name, surname, salary
FROM firm1
WHERE salary > ALL (SELECT salary
FROM firm2)
FIRMA1(rodné-č, jméno, příjmení, plat, funkce, ... )
FIRMA2(rodné-č, jméno, příjmení, plat, funkce, ... )
Example
All workers from FIRM1 who have higher salaries than at least one worker from FIRM2.
SELECT name, surname, salary
FROM firm1
WHERE salary > ANY (SELECT salary
FROM firm2)
Example
CUSTOMERS(customerID, customer-name, town, street, No, ZIP-code)
INVOICES(invoiceNo, customerID, date, ... )
List of customers who have paid no invoice in this year.
SELECT customer-name
FROM customers
WHERE customerID NOT IN
32
(SELECT customerID
FROM invoices
WHERE date >= #01.01.2005#)
More generally … WHERE Year(date) = Year(Date()))
Example: (as in the previous example using EXISTS)
CUSTOMERS(customerID, customer-name, town, street, No, ZIP-code)
INVOICES(invoiceNo, customerID, date, ... )
List of customers who have paid no invoice in this year using the EXISTS clause.
SELECT customer-name
FROM customers
WHERE NOT EXISTS
(SELECT ∗
FROM invoices
WHERE customers.customerID=invoices.customerID
AND Year(date) = Year(Date()))
Example
COMPETITION(team, points, scored, obtained, ... )
a) Create a table of a sport competition by gained points. If the number of points is equal for
more teams then order them by difference between scored and obtained goals.
b) From the table Q, given by the previous query, find the team with the highest number of
points. If more than one teams have the highest number of points then display all of them.
ad a)
SELECT team, SUM(points) AS Spoints,
SUM(scored) AS Sscored, SUM(obtained) AS Sobtained
FROM competition
GROUP BY team
ORDER BY 2 DESC, SUM(scored−obtained) DESC
ad b)
‘ Q ≡ table given by the previous query
SELECT Q.team, Q.Spoints, (Q.Sscored−Q.Sobtained) AS score
FROM Q
WHERE Q.Sbody = (SELECT MAX(Q.Sbody)
FROM Q)
ORDER BY score DESC
Note:
The aggregate function MAX in the subquery relates to the whole table because the clause
GROUP BY is omitted.
33
Example:
READERS(IDreader, name, surname, ... )
BOOKS(ISBN, title, author, publisher ...)
RESERVATIONS(IDreader, ISBN)
Reader names who have reserved the book „On the road".
SELECT readers.name, readers.surname
FROM readers
WHERE readers.IDreader IN
(SELECT reservations.IDreader
FROM reservations
WHERE reservations.ISBN =
(SELECT books.ISBN
FROM books
WHERE books.title = „On the road"))
Existential and universal quantifier in SQL (∃,∀)
The proposition „for each x p(x) is satisfied " is logically equivalent to the proposition „there
is no x such that p(x) is not satisfied". Formally:
(∀x) p(x) ≡ ¬ (∃ x)( ¬ p(x))
Example:
(∀x) (∃ y): y>x
is equivalent to
¬ (∃ x)( ¬ (∃ y): y>x)
Note:
It is simpler „to think" in universal quantifiers than in negations of existential quantifiers.
In SQL the universal quantifier is not defined.
Note:
The expression ... EXISTS (SELECT ∗ ... ) is evaluated as true if the set of values in
brackets is nonempty.
Example:
Names of the readers who have reserved at least one book.
FROM readers
WHERE readers.IDreader IN
(SELECT reservations.IDreader
FROM reservations)
34
Example:
Determine names of the readers who have reserved at least one book using the EXISTS
clause.That means we want to determine such readers that there is a book reserved by them.
FROM readers
WHERE EXISTS
(SELECT ∗
FROM reservations
WHERE readers.IDreader =
reservations.IDreader)
Example:
Numbers of readers that have reserved at least one book, but no book published by UNIS.
(i) SELECT DISTINCT reservations.IDreader
FROM reservations
WHERE reservations.ISBN NOT IN
(SELECT books.ISBN
FROM books
WHERE books.publisher = "UNIS")
wrong
(ii) SELECT DISTINCT reservations.IDreader
FROM reservations, books
WHERE reservations.ISBN = books.ISBN
AND books.publisher <> "UNIS"
The following solution is correct.
(iii) SELECT reservations.IDreader
FROM reservations, reservations AS R2
WHERE NOT EXISTS
(SELECT ∗
FROM reservations
WHERE reservations.IDreader = R2.IDreader
AND ISBN IN
(SELECT ISBN
FROM books
WHERE books.publisher = "UNIS"))
Example:
Readers who have reserved all books.
(i) SELECT readers.IDreader, readers.name, readers.surname
FROM readers
WHERE (SELECT DISTINCT ISBN
FROM reservations
35
=
WHERE reservations. IDreader = readers.IDreader)
(SELECT ISBN
FROM books)
(ii) With respect to used data, the sets are identical if they have the same number of elements
and thus it can also be solved as follows:
SELECT readers.IDreader, readers.name, readers.surname
FROM readers
WHERE (SELECT COUNT(DISTINCT ISBN)
FROM reservations
WHERE reservations.IDreader = readers.IDreader)
=
(SELECT COUNT(ISBN)
FROM books)
(iii) The following solution at the beginning finds numbers of reservations of each reader,
then stores them into an existing empty table with 2 columns, and finally selects among
them these whose number of reservations is equal to the number of books.
(a) INSERT INTO AuxTab(ID, number)
SELECT reservations.IDreader, COUNT(reservations.IDreader)
FROM reservations
GROUP BY reservations.IDreader
(b) SELECT readers.IDreader, readers.name, readers.surname
FROM readers, AuxTab
WHERE readers.IDreader = AuxTab.ID
AND AuxTab.number = (SELECT COUNT(ISBN)
FROM books)
2.2 Union Query
[TABLE] query1 UNION [ALL] [TABLE] query2
[UNION [ALL] [TABLE] query3
[…] ]
[ORDER BY ordering_specification]
2.3 Crosstab Query
TRANSFORM aggregate-function (expression1)
select-query
PIVOT expression2
36
Example:
TRANSFORM SUM(qPerson.time) As total-time
SELECT qPerson.birth-certificate-number, qPerson.surname, qPerson.name
FROM qPerson
GROUP BY qPerson.birth-certificate-number, qPerson.surname,
qPerson.name
PIVOT qPerson.firm
birthcertificatenumber
…
surname
name
<>
Hora
Kos
Novotný
…
Jan
Petr
Pavel
0
…
ABB
KPS
…
10
4
5
…
…
…
…
…
…
Example:
TRANSFORM COUNT(Student.year)
SELECT Student.year
FROM Student
GROUP BY Student.year
PIVOT Partition(average-results,1,3,0.50)
year
1
2
3
4
5
1 : 1.50
40
…
…
…
…
1.51 : 2
150
…
…
…
…
2.4 Update (Action) Queries
Creation of a new table.
(copying data from the other table).
SELECT [ALL | DISTINCT | ... ]
list-of-fields
INTO new-table [IN external-database]
FROM source-table
Insertion of one record into an existing table or query.
INSERT INTO { table | query }
[(list of fields into which data are inserted)]
37
2.01 : 2.50
250
…
…
…
…
2.51 : 3
60
…
…
…
…
VALUES (list of values)
Selection of records from one table and their insertion into new records of the other
table.
INSERT INTO { table | query }
[(list of fields into which data are inserted)]
SELECT ...
FROM ...
WHERE ...
Updating fields in a table (in tables)
(in 1∝: relationship, a referential integrity for update can be used)
UPDATE { table | query | table_joined_by_a_relationship }
[IN external-database]
SET column-name = { expression | NULL }
[, ...]
WHERE search-condition
Deletion of records in a table (in tables)
(in 1∝: relationship, a referential integrity for deletion can be used)
DELETE [∗ | table.∗]
FROM { table | list-of-tables | query |
table_joined_by_a_relationship }
[IN external-database]
WHERE search-condition
2.5 Definition Queries
Creation of a new table,
definition of fields (name, data type, size) and indices.
CREATE TABLE table
(field1 data-type[(size)]
[NOT NULL] [CONSTRAINT name-of-index1...]
[, field2 data-type[(size)]
[NOT NULL] [CONSTRAINT name-of-index2...]
[, ...]]
[,CONSTRAINT name-of-multisegment-index…
[, ...]])
Note:
For complete definition of indices see the clause CONSTRAINT in the following paragraph.
38
CONSTRAINT clause
- definition of indices (and creation of a relationship with the other table)
in commands CREATE TABLE a ALTER TABLE
Klauzule CONSTRAINT
- definice indexů (a vytvoření relace s jinou tabulkou)
v příkazech CREATE TABLE a ALTER TABLE
• Single index
CONSTRAINT index-name
{ PRIMARY KEY | UNIQUE | NOT NULL |
REFERENCES foreign-table [(for-field1, for-field2)]}
• Multisegment index
CONSTRAINT index-name
{ PRIMARY KEY (prim-segm1[,prim-segm2 [, ...]]) |
UNIQUE (uniq-segm1[, uniq-segm2 [, ...]]) |
NOT NULL (not_null-segm1[, not_null -segm2 [, ...]]) |
FOREIGN KEY (ref1[,ref2 [, ...]]) REFERENCES foreign-table
[(foreign-field1
[, foreign-field2 [, ...]])]}
Modification of an existing table structure
(adding a new field/index into an existing table or
deletion of a field/index from an existing table, respectively)
ALTER TABLE table
{ ADD {COLUMN field data-type [(size)]
[NOT NULL] [CONSTRAINT index ...] |
CONSTRAINT multisegment-index ... } |
DROP {COLUMN field | CONSTRAINT multisegment-index ...}}
Note: For complete definition of indices see the clause CONSTRAINT in the previous
paragraph.
Deletion of an existing table from a database, or deletion of an existing index from a
table.
DROP {TABLE table | INDEX index ON table}
Creation of a new index from an existing field (fields) in a table.
CREATE [UNIQUE] INDEX index
ON table (field [ASC | DESC]
[, field [ASC | DESC], ...])
[WITH { PRIMARY | DISALLOW NULL | IGNORE NULL}]
39
2.6 Computing with NULL Values, NULL in SQL
1) Arithmetic operations with NULL value
- if one of operands has NULL value, then the operation result is NULL
2) Compare operations =, <> , < , <=, > , >=
- the same as for arithmetic operations
3) Logical operations AND, OR, NOT
- in general 0 AND x = 0, 1 OR x = 1, where x is a logical expression
⇒ 0 AND NULL = 0 , NULL AND 0 = 0,
1 OR NULL = 1 , NULL OR 1 = 1
- negation
NOT (NULL) = NULL
4) In MS Access, the NULL value can be tested by means of the logical function IsNull()
5) Aggregate functions in SQL
- NULL values are included only in the aggregation COUNT(∗),
in all other aggregations: COUNT(field), AVG(expression), SUM(expression), … they
are omitted !!! (Rule 1 is not applied here)
40
3. Visual Basic for Applications (VBA)
3.1 Definitions and Declarations
Definition of constants
[Public | Private] Const name [As data_type] = constant_expression
Private (default) – constant is reachable only in the module where was defined,
Public in declaration section of module, form or report – global usage,
data_type:
Byte, Integer, Long, Single, Double, Currency, Date,
Boolean,
String,
Variant
Note:
Data type Variant is more flexible (it is the data type of all controls in forms and
reports), but it has the lowest efficiency (Access must determine the current data type by the
variable value).
Declaration of variables
a) default declaration
(variable name is ended by a letter expressing the variable data type)
Byte
none
Integer
%
Long
&
Single
!
Double
#
Currency
@
Date
none
Boolean
none
String
$
Variant
none
Object
none
user defined none
b) explicit declaration
more suitable approach,
if it is not predefined in Tools of Module card, then MS Access at the beginning of new
module includes the statement Option Explicit
Dim array-name[(array-size...)] [As [New] data_type]] …
array-size is specified by:
41
[bottom To] top
New – it enables implicit creation of an object;
a new instance of the object is created on first reference to it,
so it is so necessary to use the Set statement to assign the object
reference (it can’t be used for non-object variables)
Default value for bottom is 0, it can be changed as follows:
Option Base 1
Example:
Dim X As Integer, Y As Integer, S As String∗30
Dim A(10) As Single, B(1 To 100, 0 To 3) As Integer
ReDim statement
ReDim [Preserve] array-name(array-size...) As data_type …
1) Dynamic array declaration
- at first the array is defined by means of Dim without its size
- then the number of its elements is allocated by means of ReDim
Dim A() As Integer
…
ReDim A(100) As Integer
2) Dynamic change of the array size during the execution
Dim A(50) As Integer
…
ReDim Preserve A(55) As Integer
… static declaration
… dynamic change
Note:
Preserve provides loss less change of size (values of the array elements are saved;
if Preserve is not used then ReDim initializes the array elements values to Empty.
Static statement
Static name[(size...)] [As [New] data_type]] …
size is specified by:
[bottom To] top
It declares within a procedure a variable, that will be used only in this procedure (by its
nature, it is local), however, it exists also after finishing of the procedure, if the module
containing it is open (loaded into the operational memory).
42
User defined data types
[Public | Private] Type name_of_user_defined_data_type
variable-name As data_type
…
End Type
Example:
Type person
name As String∗20
surname As String∗20
End Type
3.2 Control Structures
3.2.1 Assignment Statements
variable = expression
Set object-variable = {[New] object-expression | Nothing }
3.2.2 Conditional Statements
If condition Then command1 [Else command2]
If condition Then
commands1
Else
commands2
End If
If condition Then
commands1
[[Else If condition2 Then
commands2
[Else If condition3 Then
commands3] …
[Else
commands_n]]
End If
43
Select Case tested-expression
Case list-of-values-1
commands1
Case list-of-values-2
commands2
...
[Case Else
commands-n]
End Select
3.2.3 Loop Statements
For control-variable = first To last [Step step-size]
commands1
[Exit For]
[commands2]
Next control-variable
If the main part of the loop is executed for all elements of a collection, then it is more suitable
to use the following version of the For loop.
For Each element In collection
commands1
[Exit For]
[commands2]
Next element
Do {While | Until} podmínka
příkazy1
[Exit Do]
příkazy2
Loop
Do
příkazy1
[Exit Do]
příkazy2
Loop {While | Until} podmínka
While podmínka
příkazy
Wend
44
3.2.4 Jump Statements
•
Unconditional jump on the other command in procedure or function
GoTo {label | row_number}
Example:
GoTo nav
...
nav:
•
Conditional jump when an error is evaluated
On Error {GoTo row_identifier | Resume [Next] | GoTo 0}
If only Resume is used, the programme jumps on the command that caused an error and
Access tries to do it again. Resume Next catches errors, but the programme continues
by the next command.
If GoTo 0 is used, then catching errors is cut off in the current procedure and each error
is sent to an error routine in the calling procedure. If there is no error routine, then a
window with the corresponding warning message is opened.
Note:
In error routine, we may test:
1. The value of built-in variable Err(error number).
If Err = 0, then no error happened.
2. Error description by means of the function Error.
3. It can be used the object Err and its properties, too:
Err.Description, text information about the current error
Err.Number, number of the current error.
3.2.5 With Statement
With object
commands
End With
Example:
With my_object
.Height = 2000
.Width = 2000
.Caption = "This is my denotation"
End With
45
3.2.6 Procedures and Functions
[Public | Private] [Static] Sub procedure-name ([parameter-list])
[commands1]
[Exit Sub]
[commands2]
End Sub
[Public | Private] [Static] Function function-name
([parameter-list]) As data-type
[commands1]
[function-name = expression]
[Exit Function]
[commands2]
[function-name = expression]
End Function
Public
Private
Static
Range of validity of procedures/functions
In all procedures/functions of all modules.
In all procedures/functions of the current
modules.
All variables declared (default or explicitly)
in the procedure will be kept during opening
the module containing this procedure.
Example: A counter inside of a procedure, its
value is incremented by 1 in each execution
of the procedure.
3.2.6.1 Parameters of Procedures and Functions
[Optional] [ByVal | ByRef] [ParamArray] parameter-name [As data-type]
•
•
Optional optional parameter.
It enables to declare a parameter of the Variant data type.
All parameters after the optional parameter must be optional, too. If
optional parameter is present or not can be checked by means of the
function IsMissing()
ByVal
call by value. If the real parameter is an expression, then Visual Basic
operates with it as it was declared by means of ByVal.
ByRef
call by reference. Arrays are always made accessible by reference
•
ParamArray must be last in the list of parameters.
•
46
•
•
•
•
Optional označuje nepovinný parametr. Umožňuje deklarovat parametr typu Variant.
Za nepovinným parametrem musí být všechny další parametry rovněž nepovinné. Test
nepřítomnosti nepovinných parametrů lze provést pomocí funkce IsMissing().
ByVal - volání hodnotou. Jestliže je skutečným parametrem výraz, Visual Basic s ním
zachází jako by byl deklarován pomocí ByVal.
ByRef - volání odkazem. Pole se vždy předávají odkazem.
ParamArray musí být v seznamu parametrů poslední.
3.2.6.2 Call of Procedures and Functions
•
Procedure can be called by two different ways:
Call procedure-name(list-of-real-parameters)
or
procedure-name list-of-real-parameters
•
The result of the function is a value, and therefore it can be used in all statements where
an expression is feasible, e.g. in the right side of an assignment statement:
variable = function-name (list-of-real-parameters)
Array, flexible and optional number of parameters
Note: Arrays are not managed directly but using the general data type Variant.
Sub Tests()
Dim x As Variant, arr(2) As Variant
x = Function1(175,60)
arr(0) = 175
arr(1) = 60
x = Function2(arr)
x = Function3(Array(175,60))
End Sub
Function Function1(ParamArray arr() As Variant) As Variant
arr(0) = …
arr(1) = ...
Function1 = arr
‘ structured return value
End Function
Function Function2(arr() As Variant) As Variant
...
End Function
Function Function3(arr As Variant) As Variant
47
...
End Function
Example: Testing of “empty” value (from modUtility module)
Note: Initial values of MS Access:
number
0
string
”” (empty string)
Variant
Empty
object type Nothing
Function IsNothing(varToTest As Variant) As Integer
’ it tests "logical nothing" by data types
’ Nothing:: Empty, Null, number with value of 0, empty string
’ Date/Time is never equal to Nothing
IsNothing = True
Select Case VarType(varToTest)
Case vbEmpty
Exit Function
Case vbNull
Exit Function
Case vbBoolean
If varToTest Then IsNothing = False
Case vbByte, vbInteger, vbLong, vbSingle, vbDouble, vbCurrency
If varToTest < > 0 Then IsNothing = False
Case vbDate
IsNothing = False
Case vbString
If Len(varToTest) < > 0 And varToTest < > " " Then IsNothing = False
End Select
End Function
3.3 Forms
3.3.1 Event Procedures in Forms
Example
Search a record on click of command button by the field where the cursor was before the
click.
Private Sub Command7_Click()
On Error GoTo Err_Command7_Click
Screen.PreviousControl.SetFocus
48
DoCmd.DoMenuItem acFormBar, acEditMenu, 10, , acMenuVer70
Exit-Command7_Click:
Exit Sub
Err-Command7_Click:
MsgBox Err.Description
Resume Exit_Command7_Click
End Sub
3.3.2 References to Collection Elements in Visual Basic
Forms
Forms(i)
Forms[orders]
Forms(”orders”)
… collection of opened forms
… (i+1)th opened form
… form orders
… form orders
Note:
If the name of an element of a collection is stored in a variable, e.g. it is by a parameter of a
procedure or function, then we must use the last case with round brackets but without
quotation marks
Dim form-name As String
form-name = ”orders”
...
Forms(form-name) … form orders
Example: Additional pages in the Card control in the forms
The card control reachable from form tools has only two pages;
there are two possible approaches how to add extra pages:
1) in local menu of the card control, selected in Design view
2) in VBA programme code,
(e.g. we insert two edit fields (name of form containing the card control and card
control name) and a command button in an auxiliary form.) In the OnClick event
procedure of the command button the corresponding form will be opened in the
Design view and in the card control a new page will be added and finally the form will
be closed. A skeleton of the procedure is showed as follows:
Sub AddPageInCard(form-name As String, card-name As String)
...
DoCmd.OpenForm form-name, acDesign
...
Forms(form-name).Controls(card-name).Pages.Add
DoCmd.Close
End Sub
49
Example: Find names of all open forms and their controls
Sub List-of-names1()
Dim nf As Integer, nc As Integer, i As Integer, j As Integer, s As String
Dim frm As Form
s = ""
nf = Forms.Count
If nf > 0 Then
For i = 0 To nf−1
Set frm = Forms(i)
s = s & frm.Name & Chr$(13) & Chr$(10)
nc = frm.Count
If nc > 0 Then
For j = 0 To nc−1
s = s&"
" & frm(j).Name & Chr$(13) & Chr$(10)
Next j
Else
s = s&"
no controls in this form" & Chr$(13) & Chr$(10)
End If
Next i
Else
s = s & "no opened forms" & Chr$(13) & Chr$(10) & Chr$(13) _
& Chr$(10)
End If
MsgBox s
End Sub
Find names of all open forms and their controls using For Each
Sub List-of-names2()
‘ vbCrLf = Chr$(13) & Chr$(10), vbTab = tab
Dim s As String, frm As Form, ctl As Control
s = ""
If Forms.Count > 0 Then
For Each frm In Forms
s = s & frm.Name & vbCrLf
If frm.Count > 0 Then
For Each ctl In frm.Controls
s = s & vbTab & ctl.Name & vbCrLf
Next ctl
Else
s = s & vbTab & " no controls in this form " & vbCrLf
End If
Next frm
Else
s = s & "no opened forms" & vbCrLf
End If
MsgBox s
End Sub
50
Example:
A form with no connected table containing specified criteria for a selection of data from a
table connected with another and viewing them after pressing command button in the first
form.
(A)
Option Compare Database
Option Explicit
Private Sub FindPartners_Click()
On Error GoTo Err_Command12_Click
Dim stDocName As String, stLinkCriteria As String
stDocName = "persons"
stLinkCriteria ="[sex] =" & "'" & IIf(Me![Frame0] = 1, "male", "female") & "'" _
& " AND [age] <=" & Me![f-max_age] _
& " AND [education] =" & "'" & Me![Combo11] & "'" _
& " AND [number-of-children] <=" & Me![f-max_number-of-children] _
& " AND [town] LIKE " & "'" & Me![f-town] & "∗'" _
& " AND [salary] >=" & Me![f-min_salary]
DoCmd.OpenForm stDocName, , , stLinkCriteria
Exit-Command12_Click:
Exit Sub
Err-Command12_Click:
general solution defining
default value when no data are
Resume Exit_Command12_Click
entered
End Sub
IIf(IsNull(Me![f-min_salary]),0, Me![f-min_salary]]
(B)
Simplification of the search condition
stLinkCriteria = "[sex] ='" & IIf(Me![Frame0] = 1, "male", " female") & "'" _
& " AND [age] <=" & Me![f-max_age] _
& " AND [education] ='" & Me![Combo11] & "'" _
& " AND [number-of-children] <=" & Me![f-max_number-of-children] _
& " AND [town] LIKE '" & Me![f-town] & "∗'" _
& " AND [salary] >=" & Me![f-min_salary]
51
Example: Multilevel selection
Form_Current()
SQL SELECT
Frame2_After_Update()
PERSONS(birth-certificate-number, name, surname, sex, state, ...)
STATES(sex, state)
In the first table the fields sex and state have text date type, in the second table sex has the
date type number. The second table is so called code list and it contains all possible states,
that persons can have. No key is defined here.
sex
1
1
1
1
2
2
2
2
stav
ženatý (married)
svobodný (single)
rozvedený (divorced)
vdovec (widower)
vdaná (married)
svobodná (single)
rozvedená (divorced)
vdova (widow)
Tab.: Code list of states
In the form based on the table PERSONS the state is
selected in two level (i) sex in Option Group control (ii)
this provides the corresponding 4 states are included in
ListBox control and here we select the real state. Selected
state is then directly stored in the bounded field state of the
table PERSONS, i.e. this field is contained
in the property Control Source of the ListBox.
If the Option Group is set to the 1st position then the value
"male“ is stored into the field PERSONS.sex; Option
Group in the 2nd position generates the value “female“
into the field PERSONS.sex.
52
Let us consider that Option Group control returns 1 in the 1st position and 2 in the 2nd
position. Let the ListBox name be List9 and Option Group name be Frame2. Under these
assumptions the Row Source property of the ListBox is defined by the following SQL query:
SELECT DISTINCTROW state FROM states WHERE sex=Frame2.Value;
Whenever we change the position in the Option Group control, the contents of the ListBox
must be updated. Therefore we must define the event procedure After_Update of the ListBox.
If a state of the person has been already defined then we must delete it, because it corresponds
to the previous information about sex which was mistaken. The sex must be then defined
again.
Private Sub Frame2_AfterUpdate()
sex = IIf(Frame2.Value=1,"male","female")
List9.Visible = True
List9. Requery
state = " "
End Sub
The last thing we must check when passing records of the table is to reconstruct the position
of Option Group, contents of the ListBox including pointing up the selected state. All these
action we will include into the form event procedure Form_Current(). The Else branch
corresponds to the case, when no information about sex of person is included, e.g. the end of
table was reached and we insert data into the new record. In this case we must provide that no
position is selected in Option Group control and the ListBox is not visible.
Private Sub Form_Current()
If
Not IsNull(sex) Then
Frame2.Value = IIf (sex ="male",1,2)
List9.Visible = True
List9.Requery
‘
List9.Value = state
Else
Frame2.Value = 0
List9.Visible = False
End If
End Sub
3.4 Hierarchy of MS Access Objects
•
Application engine Microsoft Jet
(interface, opened forms, reports, modules, references)
•
Database engine Microsoft Jet
(DAO (Data Access Objects) - objects for direct access to data)
•
Workspace ODBCDirect
(it enables direct access to data in ODBC sources
(Open Database Connectivity) without the database engine Microsoft Jet)
53
Hierarchy of the application engine Microsoft Jet
Hierarchy of the database engine Microsoft Jet
DBEngine
Errors
Error
Databases
Database
Containers
Workspaces
Workspace
Groups
Users
Group
Users
User
Groups
QueryDefs
User
Recordsets
Relations
TableDefs
54
Group
Database
Containers
Container
Documents
Document
QueryDefs
Recordsets
QueryDef
Relations
Recordset
Fields
Relation
Fields
Field
TableDefs
Field
TableDef
Fields
Fields
Field
Field
Parameters
Indexes
Parameter
Index
Fields
Field
Hierarchy of the workspace ODBCDirect
DBEngine
Errors
Workspaces
Error
Workspace
Connections
Databases
Connection
QueryDefs
QueryDef
Parameters
Database
Recordsets
Recordset
Fields
Parameter
Field
55
Recordsets
Recordset
Fields
Field
3.5 Object RecordSet
- object determined to manipulations with data in record level; there are 5 types of these
objects
1. Table [Set rst = db.OpenRecordset("table-name",dbOpenTable)]
records of one table, it is possible to update, i.e. to add, modify and delete records.
2.
Dynaset [Set rst = db.OpenRecordset("query-name",dbOpenDynaset)]
(dynamic set of records) table of query results (from one or more tables) in which is
possible to add, modify and delete records.
3.
Snapshot [Set rst = db.OpenRecordset("query-name",dbOpenSnapshot)]
(snapshot - static copy of a set of records) table of query results, which cannot be
updated, it is used for searching and generating reports.
4.
Forward-only [Set rst =db.OpenRecordset("query",dbOpenForwardOnly)]
the same case as Snapshot, however it does not contain cursor, records can be passed only
in forward direction.
5.
Dynamic [Set rst = db.OpenRecordset("query-name",dbOpenDynamic)]
table of query results from one or more tables in which is possible to add, modify and
delete records (only in the workspace ODBCDirect).
Note:
If the recordset type is not included, then MS Access tries in the workspace Microsoft Jet
to assign this type by the maximal functionality in order 1, 2, 3, 4;
and in the workspace Microsoft Jet ODBCDirect by the fastest answer to given query 4,
3, 2, 5.
Opening a table as a recordset in MS Access 97
Dim ws As Workspace, db As Database, rst As RecordSet
’1.
Set ws = DBEngine.Workspaces(0)
Set db = ws.OpenDatabase("file-name.mdb")
Set rst = db.OpenRecordset("table-name")
’2.
Set db = ws.Databases(0)
’3
'4.
Set db = DBEngine(0)(0)
Set db = CurrentDb()
56
Note: (Unexpected) Problems in MS Access 2000/2003
(1)
Dim db As Database, rst As RecordSet
open any module in Design view and set
Tools →
References... →
(2)
Dim db As Database, rst As RecordSet
...
To avoid generating errors, we must declare Database and Recordset as follows:
Dim db As DAO.Database, rst As DAO.RecordSet
57
Opening the SELECT query as a recordset.
Example:
Determine the highest current value of a field of the automatic number data type
Function MaxValue(table-name As String, column-name As String) As Byte
Set rst = db.OpenRecordset("SELECT COUNT(∗) As mxf0 FROM ” _
& table-name)
If rst!mxf0 = 0 Then
MaxValue = 0
Else
Set rst = db.OpenRecordset("SELECT MAX(" & column-name _
& ") As mxf0" & " FROM " & table-name)
rst.MoveFirst
MaxValue = rst!mxf0
End If
rst.Close
End Function
Record updates
Example:
Increasing the electricity rate by 10 percent for all customers
Set rst = db.OpenRecordset(”customers")
rst.MoveFirst
While Not(rst.EOF)
' Do Until rst.EOF
rst.Edit
'
rst.Edit
' record → buffer
rst![rate] = rst![rate] ∗1.1
'
rst![rate] = rst![rate] ∗1.1
rst.Update
'
rst.Update ' buffer → record
rst.MoveNext
'
rst.MoveNext
Wend
' Loop
rst.Close
The same example using the SQL command UPDATE
Dim sqlcommand As String, db As DAO.Database
sqlcommand = “UPDATE [customers] SET rate = rate ∗1.1”
(i) DoCmd.RunSQL sqlcommand
(ii) db.Execute sqlcommand
58
Insertion of a new record
...
rst.AddNew
rst![field1] = …
rst![field2] = …
…
rst.Update
Deletion of the current record
...
rst.Delete
Note: After Delete the Update method must not be used (it leads to an error).
Record sorting in recordsets of the table type (Index)
(default given by the Primary Key)
...
rst.Index = "by-surname"
…
rst.Index = "Primary Key"
Record sorting in a recordset of the dynaset or snapshot type (Sort)
Dim db As DAO.Database, rst1 As DAO.RecordSet, rst2 As DAO.RecordSet
Set rst1 = db.OpenRecordset("table-name", dbOpenDynaset)
rst1.Sort = “[surname], [name], [age] DESC”
Set rst2 = rst1.OpenRecordset()
Note:
The change of the Sort object property does not provide the change of ordering, it can be
seen in a new object which is created from it.
In most cases is faster to use a recordset based on a query with ORDER BY.
59
Record filtering in recordsets
Dim db As DAO.Database, rst1 As DAO.RecordSet, rst2 As DAO.RecordSet
Set rst1 = db.OpenRecordset("table-name", dbOpenDynaset)
rst1.Filter = "[town] ='Brno'"
Set rst2 = rst1.OpenRecordset()
Note: Filtering without the use of recordsets
(1) DoCmd.OpenForm stDocName, , , stLinkCriteria
(2) DoCmd.ApplyFilter stFilter
…
DoCmd.ShowAllRecords
‘ filtering off
Search in recordsets of the table type by an index (Seek)
(i) Before the use of Seek, the current index must be set in the property
Index
(ii) Seek finds the first record, whose key value satisfies the comparison
criterion
recordset.Seek comparing-operator, key1[,key2]...
Example:
Set rst = db.OpenRecordset("students")
rst.Index = "by surname and name"
‘ multisegment index
rst.Seek "=", "Malý", "Miroslav"
If rst.NoMatch Then
MsgBox "required record is not found"
End If
...
Search in recordsets of the dynaset or snapshot type (Find...)
Example: Update records with missing telephone numbers
it must not be
…
omitted,
otherwise
an error is evaluated
Dim strFind, strMsg, strTab As String
strTab = "Customers"
Set rst = db.OpenRecordset(strTab,dbOpenDynaset)
strFind = "IsNull([telephone])"
rst.FindFirst strFind
‘ index is not required
60
Do Until rst.NoMatch
rst.Edit
strMsg = "Enter the telephone number of the customer: " _
& rst![surname] & " " & rst![name]
rst![telephone] = InputBox(strMsg)
rst.Update
rst.FindNext strFind
Loop
rst.Close
Example:
General solution – insertion of data into the arbitrary table and its arbitrary column with
displaying the defined data.
Sub Enter_the_value_of(table-name As String, column-name As String)
Dim db As Database, rst As Recordset, f As Field, sTab As String
Dim strFind As String, s-record As String, s As String, i As Integer
Set rst = db.OpenRecordset(table-name, dbOpenDynaset)
strFind = "IsNull([" & column-name & ”])"
Do Until rst.NoMatch
rst.Edit
s-record = ""
For Each f In rst.Fields ‘ copy of values of all record fields
Select Case VarType(rst.Fields(f.Name))
Case vbString
s = rst.Fields(f.Name)
Case vbByte, vbInteger, vbLong, vbSingle, _
vbDouble, vbCurrency
s = Str(rst.Fields(f.Name))
Case vbBoolean
61
s = IIf(rst.Fields(f.Name), "True", "False")
Case vbDate
s = Format(rst.Fields(f.Name), "dd.mm.yy")
Case Else
s = ""
End Select
sTab = IIf(InStr(rst.Fields(f.Name), " "), vbTab, vbTab & vbTab)
s-record = s-record & f.Name & sTab & ": " & s & vbCrLf
Next f
rst.Fields(column-name) = InputBox(s-record & vbCrLf & _
"Enter the value of " & column-name & ": ")
rst.Update
rst.FindNext strFind
Loop
rst.Close
End Sub
Alternative expression of the For loop in the previous solution
For i = 0 To rst.Fields.Count − 1
Select Case VarType(rst.Fields(rst.Fields(i).Name))
Case vbString
s = rst.Fields(rst.Fields(i).Name)
Case vbByte, vbInteger, vbLong, vbSingle, _
vbDouble, vbCurrency
s = Str(rst.Fields(rst.Fields(i).Name))
Case vbBoolean
s = IIf(rst.Fields(rst.Fields(i).Name), "True", "False")
Case vbDate
s = Format(rst.Fields(rst.Fields(i).Name), "dd.mm.yy")
Case Else
s = ""
End Select
sTab = IIf(InStr(rst.Fields(i).Name, " "), vbTab, vbTab & vbTab)
s-record = s-record & rst.Fields(i).Name & sTab & ": " & s & vbCrLf
Next f
Recordset clone
1) copy of the form Record Source (i.e. the table or query on which the form is based),
2) RecordsetClone form property and the object Recordset can be used for synchronization
of the Recordset record with the current form record.
62
Example: Search in the clone with a setting of the current form record
Sub Reader-list_AfterUpdate()
‘ it generates after a selection in list of readers
Dim rst As DAO.Recordset, strFind As String
Set rst = Me.RecordsetClone
strFind = Str(Me! Reader-list)
rst.FindFirst " IDreader = " & strFind
If rst.NoMatch Then
MsgBox "Reader with given ID is not found"
Else
Me.Bookmark = rst.Bookmark ‘ found record is displayed
End If
rst.Close
End Sub
Example: Search in the clone with a setting of the current form record
(the 2nd version – searching by the beginning of the reader surname defined after
click on a command button by means of InputBox)
Sub FindReader_Click()
‘ generated after the command button click
Dim rst As DAO.Recordset, strFind As String
Set rst = Me.RecordsetClone
strFind = "[surname] LIKE '" & InputBox("Enter the first letters " _
& "of the searched reader name ") & "∗'"
If rst.NoMatch Then
MsgBox ”Reader of this surname is not found"
Else
Me.Bookmark = rst.Bookmark ‘ found record is displayed
End If
rst.Close
End Sub
Example:
Multiply the field amount in all records of the subform table by the factor defined in the other
form opened after the click on a command button.
Sub Multiplying_by_Factor_Click()
Dim rst As Recordset, dblFactor As Double
DoCmd.OpenForm “form-factor”,,,,,acDialog
If IsNull(Forms![form-factor]![factor]) _
Or Forms![form-factor]![factor]=0 Then
DoCmd.Close acForm, “form-factor”
Exit Sub
End If
DoCmd.Hourglass True
63
dblFactor = CDbl(Forms![form-factor]![factor])
Set rst = Me! [subform-name].Form.RecordsetClone
rst.MoveFirst
While (Not(rst.EOF))
rst.Edit
rst![amount] = rst![amount]∗ dblFaktor
rst.Update
rst.MoveNext
Wend
rst.Close
Me.SetFocus
DoCmd.Hourglass False
End Sub
3.6 Calling SQL from VBA
1.
Saved query (SELECT, crosstab, … )
DoCmd.OpenQuery query-name [, view][, data-mode]
view:
acViewDesign, acViewNormal (default, query result),
acViewPreview (page preview)
data-mode:
acAdd, acEdit (default), acReadOnly
2.
SELECT query
Set rst = db.OpenRecordset(select_query,dbOpenDynaset)
3.
Action a definition queries
True (default), False
DoCmd.RunSQL query [, use-transaction]
or
db.Execute query [, options]
‘ with confirmation
‘ without confirmation
Action:
INSERT INTO, DELETE, UPDATE, SELECT INTO,
definition: CREATE TABLE, DROP TABLE, ALTER TABLE,
CREATE INDEX, DROP INDEX.
The execution of DoCmd.RunSQL query is slower than db.Execute query.
If we want to execute an action or definition SQL command by means of the Execute method
and require a confirmation of this action, then we place before this command an InputBox or
MsgBox command
MsgBox(prompt [,buttons][,title])
64
Example:
...
Dim strQ As String, strTable As String
strQ = “DELETE ∗ FROM “ & strTabulka
If MsgBox(“Are you sure in deleting all records in the table “ & _
strTable, & “?”, vbYesNo) = vbYes Then
CurrentDb.Execute strQ
End If
...
Example: Find the maximal value assigned to a given field.
Function MaxValue(given-table As String, given-field As String) As Byte
Set rst = db.OpenRecordset("SELECT COUNT(∗) As mxf0 FROM " & given-table)
If rst!mxf0 = 0 Then
MaxValue = 0
Else
Set rst = db.OpenRecordset("SELECT MAX(" & given-field & ") As mxf0 " & _
"FROM " & given-table)
rst.MoveFirst
MaxValue = rst!mxf0
End If
rst.Close
End Function
Transactions in MS Access
Example: "Thermometer", hour-glass, loop, transaction.
…
Dim ws As Workspace, rst As DAO.Recorset, thermometer As Variant, ...
Set rst = CurrentDb.OpenRecordset("table-name")
thermometer = SysCmd(acSysCmdInitMeter,“info-text", number)
DoCmd.Hourglass True
ws.BeginTrans
...
For i = 1 To number
…
rst.AddNew
...
rst.Update
...
65
thermometer = SysCmd(acSysCmdUpdateMeter, i)
Next i
ws.CommitTrans
rst.Close
DoCmd.Hourglass False
thermometer = SysCmd(acSysCmdClearStatus)
4. Database Application
This application will be explained in more detail in exercises. Here we present only selected
procedures.
Fig. 1. Application menu
66
Fig. 4.2
Option Explicit
Dim ppp As Integer, ccc As Integer, kkk As Single
Dim sss As String
Private Sub Form_Load()
TabCtl33.Value = 0
' první stránka na kartě
ListTypStudia.Value = "MS" ' typ studia
ListRocnik.Value = 1
' ročník
ListPredmety.Requery
' vybraný seznam předmětů
ListUcitele.Value = 1
' učitel
ComboFunkce.Value = 201 ' funkce
Label_pom0.Visible = False
LabelCv.Caption = " "
ComboZk.Value = " "
ListUcFun.Value = Null
' ListUcFun.Requery
ListUcOst.Value = Null
ListUcOst.Requery
TextPocetOstatni.Value = 0
' TextPocetOstatni.Enabled = False
CommandSaveChange.Enabled = False
CheckTydny.Value = False
TextTydny.Enabled = False
67
TextSkupiny.Enabled = False
TextStudenti.Enabled = False
CheckTydny.Enabled = False
ComboTyp_prcv.Enabled = False
TextPredmet.Enabled = False
End Sub
Private Sub InicializaceDetailů(enab As Integer)
TextTydny.Enabled = False
CheckTydny.Value = False
TextSkupiny.Value = 0
TextStudenti.Value = 0
ComboTyp_prcv.Value = 0
LabelCv.Caption = " "
ComboZk.Value = " "
If enab = 1 Then
TextSkupiny.Enabled = False
TextStudenti.Enabled = False
CheckTydny.Enabled = False
ComboTyp_prcv.Enabled = False
TextPredmet.Enabled = False
End If
End Sub
Private Sub ListUcitele_AfterUpdate()
ListUcOst.Requery
End Sub
Private Sub ComboOstatni_AfterUpdate()
' TextPocetOstatni.Enabled = True
End Sub
Private Sub ListTypStudia_AfterUpdate() ' typ studia
ListRocnik.Value = 1
Select Case ListTypStudia.Value
Case "DS"
ListRocnik.RowSource = "1"
Case "BS"
ListRocnik.RowSource = "1;2;3"
Case "MS"
ListRocnik.RowSource = "1;2;3;4;5"
Case "DIS"
ListRocnik.RowSource = "1;2;3;4;5;6"
End Select
ListRocnik.Requery
TextPredmet.Value = " "
TextTydny.Value = 0
InicializaceDetailů (1)
If ListTypStudia.Value = "DIS" Then
Else
End If
End Sub
Private Sub ListRocnik_AfterUpdate()
' ročník
68
ListPredmety.Value = 0
TextPredmet.Value = " "
TextTydny.Value = 0
End Sub
Private Sub ListPredmety_AfterUpdate() ' předměty
Dim db As Database, rst As Recordset
Set rst = db.OpenRecordset("predmety")
rst.Index = "PrimaryKey"
rst.Seek "=", ListPredmety.Value
TextSkupiny.Enabled = True
TextStudenti.Enabled = True
CheckTydny.Enabled = True
ComboTyp_prcv.Enabled = True
' TextPredmet.Enabled = True
TextPredmet.Value = rst!nazev
TextTydny.Value = rst!tydnu
ppp = rst!predn
ccc = rst!cvic
sss = rst!semestr
rst.Close
If sss = "zim" Then
Label_pom5.Caption = 0 ' t_LS
Label_pom7.Caption = 0 ' h_LS
Else
Label_pom4.Caption = 0 ' t_ZS
Label_pom6.Caption = 0 ' h_ZS
End If
' další složky z recordsetu
End Sub
Private Sub CheckTydny_AfterUpdate()
TextTydny.Enabled = CheckTydny.Value
End Sub
Private Sub CommandPridatFunkci_Click()
On Error GoTo Err_CommandPridatFunkci_Click
Dim strQ As String, mx As Integer
'(1) Set rst = db.OpenRecordset("uc_fun")
' mx = 0
' rst.MoveFirst
' While Not rst.EOF
'
If rst!IDautom > mx Then mx = rst!IDautom
'
rst.MoveNext
' Wend
' mx = mx + 1
' MsgBox "mx1=" + Str(mx)
' rst.Close
'(2) Set rst = db.OpenRecordset("MXuc_fun", dbOpenDynaset)
' rst.MoveFirst
' mx = rst!mxf + 1
69
'
'
MsgBox "mx2=" + Str(mx)
rst.Close
'(3) Set rst = db.OpenRecordset("SELECT MAX(IDautom) As mxf0 FROM uc_fun")
' rst.MoveFirst
' mx = rst!mxf0 + 1
' MsgBox "mx3=" + Str(mx)
' rst.Close
'(4)
mx = MaxHodnota("uc_fun", "IDautom") + 1
' MsgBox "MaxHodnota=" + Str(mx)
Label_pom0.Caption = mx
If Not IsNull(ListUcitele.Value) And Not IsNull(ComboFunkce.Value) Then
strQ = "INSERT INTO uc_fun" _
& "(IDuc,IDfu,IDautom)" _
& "VALUES (ListUcitele.Value,ComboFunkce.Value,Label_pom0.Caption)"
'
& "VALUES (ListUcitele.Value,ComboFunkce.Value,MaxHodnota('uc_fun', 'IDautom') + 1)"
DoCmd.RunSQL strQ
ListUcFun.Requery
Else
MsgBox "Nový záznam o funkci nelze zapsat," & vbCrLf & _
"protože údaje jsou neúplné"
End If
'(5) If Not IsNull(ListUcitele.Value) And Not IsNull(ComboFunkce.Value) Then
'
strQ = "INSERT INTO uc_fun" _
'
& "(IDuc,IDfu" _
'
& "VALUES (ListUcitele.Value,ComboFunkce.Value)"
'
DoCmd.RunSQL strQ
'
ListUcFun.Requery
' Else
'
MsgBox "Nový záznam o funkci nelze zapsat," & vbCrLf & _
'
' End If
Exit_CommandPridatFunkci_Click:
Exit Sub
Err_CommandPridatFunkci_Click:
Resume Exit_CommandPridatFunkci_Click
End Sub
Private Sub CommandZrusitFunkci_Click()
On Error GoTo Err_CommandZrusitFunkci_Click
Dim strQ As String
If Not IsNull(ListUcFun.Value) Then
strQ = "DELETE * FROM uc_fun WHERE IDautom=ListUcFun.Value"
DoCmd.RunSQL strQ
ListUcFun.Value = Null
ListUcFun.Requery
Else
MsgBox "Nelze nic zrušit, protože žádný záznam" & vbCrLf & _
"o zastávané funkci nebyl vybrán"
End If
Exit_CommandZrusitFunkci_Click:
Exit Sub
Err_CommandZrusitFunkci_Click:
Resume Exit_CommandZrusitFunkci_Click
70
End Sub
Private Sub CommandPridatOstatni_Click()
On Error GoTo Err_CommandPridatOstatni_Click
Dim strQ As String, mx As Integer
mx = MaxHodnota("uc_ost", "IDautom") + 1
If Not IsNull(ListUcitele.Value) And Not IsNull(ComboOstatni.Value) _
And TextPocetOstatni.Value > 0 Then
strQ = "INSERT INTO uc_ost" _
& "(IDuc,IDost,pocet,IDautom)" _
& "VALUES (ListUcitele.Value,ComboOstatni.Value,TextPocetOstatni.Value,Label_pom1.Caption)"
DoCmd.RunSQL strQ
ListUcOst.Requery
Else
MsgBox "Nový záznam o činnosti nelze zapsat," & vbCrLf & _
End If
Exit_CommandPridatOstatni_Click:
Exit Sub
Err_CommandPridatOstatni_Click:
Resume Exit_CommandPridatOstatni_Click
End Sub
Private Sub CommandZrusitOst_Click()
On Error GoTo Err_CommandZrusitOst_Click
Dim strQ As String
If Not IsNull(ListUcOst.Value) Then
strQ = "DELETE * FROM uc_ost WHERE IDautom=ListUcOst.Value"
DoCmd.RunSQL strQ
ListUcOst.Value = Null
ListUcOst.Requery
Else
"o ostatní činnosti učitele nebyl vybrán"
End If
Exit_CommandZrusitOst_Click:
Exit Sub
Err_CommandZrusitOst_Click:
Resume Exit_CommandZrusitOst_Click
End Sub
Private Sub CommandOpravitOst_Click()
On Error GoTo Err_CommandOpravitOst_Click
Dim strQ As String
If Not IsNull(ListUcOst.Value) Then
Set rst = db.OpenRecordset("uc_ost")
rst.Seek "=", ListUcOst.Value
' TextPocetOstatni.Enabled = True
Label_pom1.Caption = rst!IDautom
ComboOstatni.Value = rst!IDost
TextPocetOstatni.Value = rst!pocet
rst.Close
71
ListUcitele.Enabled = False
TextPocetOstatni.SetFocus ' změna fokusu, aby se tlačítko opět mohlo znepřístupnit
CommandSaveChange.Enabled = True
Else
MsgBox "Nelze nic opravovat, protože žádný záznam" & vbCrLf & _
"o ostatní činnosti učitele nebyl vybrán"
End If
Exit_CommandOpravitOst_Click:
Exit Sub
Err_CommandOpravitOst_Click:
Resume Exit_CommandOpravitOst_Click
End Sub
Private Sub CommandSaveChange_Click()
On Error GoTo Err_CommandSaveChange_Click
Dim strQ As String
strQ = "UPDATE uc_ost SET IDost=ComboOstatni.Value, pocet=TextPocetOstatni.Value " & _
"WHERE IDautom=Label_pom1.Caption"
DoCmd.RunSQL strQ
ListUcOst.Requery
ListUcitele.Enabled = True
ComboOstatni.SetFocus
CommandSaveChange.Enabled = False
Exit_CommandSaveChange_Click:
Exit Sub
Err_CommandSaveChange_Click:
Resume Exit_CommandSaveChange_Click
End Sub
Private Sub ComboTyp_prcv_AfterUpdate()
Set rst = db.OpenRecordset("pred_cv")
rst.Seek "=", ComboTyp_prcv.Value
kkk = rst!koef
rst.Close
Select Case ComboTyp_prcv.Value
Case 1, 7, 11, 15
LabelCv.Caption = "P"
Select Case ListPredmety.Value
Case "1in", "1in-", "ai", "bzi", "0in", "dtx", "fza", "rdb", "rmt", "rps", "scn", _
"vci", "vir", "vjc", "vm2", "v2a", "vzp", "vb0", "vd", "vdp", "vr0", "vu0"
ComboZk.Value = " "
Case Else
ComboZk.Value = "zk"
End Select
Case 2
LabelCv.Caption = "Konz"
ComboZk.Value = "zk"
Case 3, 8, 12, 16
LabelCv.Caption = "C1"
Case "dtx", "fza", "rdb", "rmt", "rps", "scn", _
"vci", "vir", "vjc", "vm2", "v2a", "vzp", "vb0"
ComboZk.Value = "kz"
Case "bzi", "0in", "vd", "vdp", "vr0", "vu0"
ComboZk.Value = "z"
72
Case Else
ComboZk.Value = " "
End Select
Case 4, 9, 13, 17
LabelCv.Caption = "C2a"
Case "1in", "1in-", "ai", "dtx", "fza", "rdb", "rmt", "rps", "scn", _
ComboZk.Value = "z"
Case Else
ComboZk.Value = " "
End Select
Case 5, 10, 14, 18
LabelCv.Caption = "C2b"
Case "1in", "1in-", "ai", "dtx", "fza", "rdb", "rmt", "rps", "scn", _
ComboZk.Value = "z"
Case Else
ComboZk.Value = " "
End Select
Case 6
LabelCv.Caption = "sem."
ComboZk.Value = " "
End Select
End Sub
Private Sub CommandSaveUV_Click()
On Error GoTo Err_CommandSaveUV_Click
Dim strQ As String, mx As Integer, koef_zk As Single
mx = MaxHodnota("uc_uv", "IDuv") + 1
Select Case ListTypStudia.Value
Case "DS"
Label_pom3.Caption = "51"
Case "BS"
Case "MS"
Case "DIS"
Label_pom3.Caption = "??"
End Select
If sss = "zim" Then
Label_pom4.Caption = TextTydny.Value ' t_ZS
Label_pom6.Caption = IIf(Left(LabelCv.Caption, 1) = "C", ccc, ppp) ' h_ZS
Else
Label_pom5.Caption = TextTydny.Value ' t_LS
Label_pom7.Caption = IIf(Left(LabelCv.Caption, 1) = "C", ccc, ppp) ' h_LS
End If
Label_pom8.Caption = kkk
Select Case ComboZk.Value
Case "zk"
koef_zk = 0.7
Case "kz"
koef_zk = 0.5
Case Else
73
koef_zk = 0
End Select
If IsNull(ComboTyp_prcv.Value) Or (TextSkupiny.Value = 0) Or _
(TextStudenti.Value = 0) Then
MsgBox "Nový záznam o výuce nelze zapsat," & vbCrLf & _
Else
Label_pom9.Caption = (Label_pom4.Caption * Label_pom6.Caption + _
Label_pom5.Caption * Label_pom7.Caption) * TextSkupiny.Value * kkk _
+ TextStudenti.Value * koef_zk
strQ = "INSERT INTO uc_uv" _
& "(IDuv,IDuc,IDpred,rocnik,forma_st,t_ZS,t_LS,h_ZS,h_LS," & _
"IDprcv,typ_prcv,forma_zk,n_skupin,n_stud,koef,sum_radek)" & _
"VALUES (Label_pom2.Caption,ListUcitele.Value,ListPredmety.Value," & _
"ListRocnik.Value,Label_pom3.Caption," & _
"Label_pom4.Caption,Label_pom5.Caption,Label_pom6.Caption,Label_pom7.Caption," & _
"ComboTyp_prcv.Value,LabelCv.Caption,ComboZk.Value," & _
"TextSkupiny.Value,TextStudenti.Value,Label_pom8.Caption,Label_pom9.Caption)"
DoCmd.RunSQL strQ
ListUcOst.Requery
End If
Exit_CommandSaveUV_Click:
Exit Sub
Err_CommandSaveUV_Click:
Resume Exit_CommandSaveUV_Click
End Sub
Private Sub CommandKonec_Click()
On Error GoTo Err_CommandKonec_Click
DoCmd.Close
Exit_CommandKonec_Click:
Exit Sub
Err_CommandKonec_Click:
Resume Exit_CommandKonec_Click
End Sub
Source row of subject list is represented by the following query:
SELECT DISTINCTROW [predmety].[kod], [predmety].[rocnik], [predmety].[semestr],
[predmety].[nazev], [predmety].[studium], [predmety].[obor], [predmety].[tydnu],
[predmety].[predn], [predmety].[cvic], [predmety].[typcvic], [predmety].[kredit], [predmety].[zk]
FROM [predmety] WHERE studium=ListTypStudia.Value AND rocnik=ListRocnik.Value;
Teaching + zk, kz:
SELECT DISTINCTROW [Uc_UV].[IDuv], [Uc_UV].[rocnik], [Uc_UV].[forma_st],
[Uc_UV].[IDpred], [Uc_UV].[typ_prcv], [Uc_UV].[koef], [predmety].[nazev], [Uc_UV].[t_ZS],
[Uc_UV].[t_LS], [Uc_UV].[h_ZS], [Uc_UV].[h_LS], [Uc_UV].[forma_zk], [predmety].[obor],
[Uc_UV].[n_skupin], [Uc_UV].[n_stud], [Uc_UV].[sum_radek] FROM Uc_UV,predmety
WHERE Uc_UV.IDuc=ComboV_uc.Value AND Uc_UV.IDpred=predmety.kod;
74
Fig. 4.3. Calculations of ZH
Option Explicit
Private Sub Form_Load()
Me!ComboV_uc = 0
ListV_ostatni.Requery
ListV_funkce.Requery
ListV_vyuka.Requery
End Sub
Private Sub ComboV_uc_AfterUpdate()
Dim a As Single, celkem As Single
celkem = 0
Me!Textsum_cin = 0
Me!Textsum_fun = 0
Me!Textsum_vyuka = 0
Set rst = db.OpenRecordset("SELECT SUM(extra_cin.koef * uc_ost.pocet) " _
& "AS sum_cin " _
& "FROM uc_ost,extra_cin " _
& "WHERE uc_ost.IDuc=" & Me!ComboV_uc & " AND " _
& "uc_ost.IDost=extra_cin.IDextra", dbOpenSnapshot)
If IsNull(rst!sum_cin) Then
a=0
Else
rst.MoveFirst
a = rst!sum_cin
75
Me!Textsum_cin = Format(a, "###0.0")
End If
ListV_ostatni.Requery
rst.Close
celkem = celkem + a
Set rst = db.OpenRecordset("SELECT SUM(funkce.ZH) AS sum_fun " _
& "FROM uc_fun,funkce " _
& "WHERE uc_fun.IDuc=" & Me!ComboV_uc & " AND " _
& "uc_fun.IDfu=funkce.IDfun", dbOpenSnapshot)
If IsNull(rst!sum_fun) Then
a=0
Else
rst.MoveFirst
a = rst!sum_fun
Me!Textsum_fun = Format(a, "###0.0")
End If
ListV_funkce.Requery
rst.Close
celkem = celkem + a
Set rst = db.OpenRecordset("SELECT SUM(uc_UV.sum_radek) AS sum_vyuka " _
& "FROM uc_UV " _
& "WHERE uc_UV.IDuc=" & Me!ComboV_uc, dbOpenSnapshot)
If IsNull(rst!sum_vyuka) Then
a=0
Else
rst.MoveFirst
a = rst!sum_vyuka
Me!Textsum_vyuka = Format(a, "###0.0")
End If
ListV_vyuka.Requery
rst.Close
celkem = celkem + a
Me!TextSum_ZH = Format(celkem, "###0.0")
End Sub
Private Sub CommandCelkemOdbory_Click()
On Error GoTo Err_CommandCelkemOdbory_Click
Dim db As Database
Dim rstOdb As Recordset, rstUc As Recordset, rst As Recordset
Dim ZH As Single, ost As Single, fun As Single, vyuka As Single
Dim celkemUc As Single, celkem As Single
Dim strQ As String
strQ = "DELETE * FROM VyslOdbory"
DoCmd.RunSQL strQ
Set rstOdb = db.OpenRecordset("VyslOdbory")
Set rstUc = db.OpenRecordset("Ucitele")
rstUc.MoveFirst
celkem = 0
Do While Not rstUc.EOF
celkemUc = 0
Set rst = db.OpenRecordset("SELECT SUM(uc_UV.sum_radek) AS sum_vyuka " _
76
& "FROM uc_UV " _
& "WHERE uc_UV.IDuc=" & rstUc!IDped, dbOpenSnapshot)
If IsNull(rst!sum_vyuka) Then
vyuka = 0
Else
rst.MoveFirst
vyuka = rst!sum_vyuka
End If
rst.Close
celkemUc = celkemUc + vyuka
Set rst = db.OpenRecordset("SELECT SUM(extra_cin.koef * uc_ost.pocet) " _
& "AS sum_cin " _
& "FROM uc_ost,extra_cin " _
& "WHERE uc_ost.IDuc=" & rstUc!IDped & " AND " _
& "uc_ost.IDost=extra_cin.IDextra", dbOpenSnapshot)
If IsNull(rst!sum_cin) Then
ost = 0
Else
rst.MoveFirst
ost = rst!sum_cin
End If
rst.Close
celkemUc = celkemUc + ost
Set rst = db.OpenRecordset("SELECT SUM(funkce.ZH) AS sum_fun " _
& "FROM uc_fun,funkce " _
& "WHERE uc_fun.IDuc=" & rstUc!IDped & " AND " _
& "uc_fun.IDfu=funkce.IDfun", dbOpenSnapshot)
If IsNull(rst!sum_fun) Then
fun = 0
Else
rst.MoveFirst
fun = rst!sum_fun
End If
rst.Close
celkemUc = celkemUc + fun
rstOdb.AddNew
rstOdb!Iduc = rstUc!IDped
rstOdb!odbor = rstUc!odbor
rstOdb!jmeno = rstUc!jmeno
rstOdb!ZH = vyuka
rstOdb!ost = ost
rstOdb!fun = fun
rstOdb!Uc_celkem = celkemUc
rstOdb.Update
rstUc.MoveNext
celkem = celkem + celkemUc
Loop
rstOdb.Close
rstUc.Close
ListUAI.Requery
ListOdbory.Requery
ListSumyUc.Requery
77
Exit_CommandCelkemOdbory_Click:
Exit Sub
Err_CommandCelkemOdbory_Click:
Resume Exit_CommandCelkemOdbory_Click
End Sub
Private Sub CommandZrusitVyuku_Click()
On Error GoTo Err_CommandZrusitVyuku_Click
Dim strQ As String
If Not IsNull(ListV_vyuka) Then
strQ = "DELETE * FROM uc_uv WHERE IDuv=ListV_vyuka.Value"
DoCmd.RunSQL strQ
ListV_vyuka.Value = Null
ListV_vyuka.Requery
Call ComboV_uc_AfterUpdate
Else
"o výuce předmětu nebyl vybrán"
End If
Exit_CommandZrusitVyuku_Click:
Exit Sub
Err_CommandZrusitVyuku_Click:
Resume Exit_CommandZrusitVyuku_Click
End Sub
Private Sub CommandOpravitVyuku_Click()
On Error GoTo Err_CommandOpravitVyuku_Click
Dim stDocName As String
Dim stLinkCriteria As String
If Not IsNull(ListV_vyuka) Then
stDocName = "OpravaVyuky"
DoCmd.OpenForm stDocName, , , stLinkCriteria, , , ListV_vyuka
Else
MsgBox "Nelze nic opravovat, protože žádný záznam" & vbCrLf & _
"o výuce předmětu nebyl vybrán"
End If
Exit_CommandOpravitVyuku_Click:
Exit Sub
Err_CommandOpravitVyuku_Click:
Resume Exit_CommandOpravitVyuku_Click
End Sub
Private Sub CommandKonecVypoctu_Click()
On Error GoTo Err_CommandKonecVypoctu_Click
DoCmd.Close
Exit_CommandKonecVypoctu_Click:
Exit Sub
Err_CommandKonecVypoctu_Click:
Resume Exit_CommandKonecVypoctu_Click
End Sub
78
References
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]
[10]
[11]
[12]
[13]
[14]
[15]
[16]
[17]
[18]
[19]
[20]
[21]
[22]
[23]
[24]
[25]
[26]
[27]
[28]
Benyon-Davies, P.: Database Systems. Macmillan Press, London, 1996. ISBN 0-33363667-8.
Bíla, J., Král, F.: Databázové a znalostní systémy. Skriptum ČVUT FS, Praha, 1999.
Connolly, T. and Begg, C.: Database Systems: A Practical Approach to Design,
Implementation, and Management. Addison Wesley, 2001. ISBN 0201708574.
Date, C.J.: An Introduction to Database Systems. Addison Wesley, 2003. ISBN
0321197844.
Duží, M.: Konceptuální modelování – datový model HIT. Slezská univerzita, Ostrava,
2000.
Elmasri, R. and Navathe, S.B.: Fundamentals of Database Systems. Addison Wesley,
2003. ISBN 0321122267.
Farana, R.: Tvorba relačních databázových systémů. VŠB TU, Ostrava, 1999.
Farana, R.: Aplikace počítačů v řízení. Relační databáze. VŠB TU, Ostrava, 1995.
Fortier, P.J.: Database Systems Handbook. McGraw-Hill, 1997, ISBN 0-07-021626-6.
Garcia-Molina, H., Ullman, J.D. and Widom, J.D.: Database Systems: The Complete
Book. Prentice Hall, 2001. ISBN 0130319953.
Halaška, I., Pokorný, J., Valenta, M.: Databázové systémy. Cvičení. Skriptum ČVUT
FEL, Praha, 2004.
Havlát, T., Benešovský, M.: Úvod do databázových systémů. Skriptum UJEP PřF, Brno,
1984.
Hellerstein, J.M. and Stonebraker, M. (eds.): Readings in Database Systems. The MIT
Press, 2005. ISBN 0262693143.
Lacko, L.: PHP a MySQL. CP Books, Brno, 2005.
Lacko, L.: SQL. Computer Press, Brno, 2003.
McCullough-Dieter, C.: Mistrovství v Oracle 8. Computer Press, Praha, 1999.
Pokorný, J.: Visual Basic pro aplikace Accessu 2000. Kopp, České Budějovice, 2000.
Pokorný, J.: Office 97 a Internet. Kopp, České Budějovice, 1997.
Pokorný J.: Učíme se SQL. PLUS, Praha, 1993.
Pokorný, J.: Konstrukce databázových systémů. Skriptum ČVUT FEL, Praha, 2004.
Pokorný, J., Halaška, I.: Databázové systémy. Skriptum ČVUT FEL, Praha, 2004.
Pokorný, J., Halaška, I.: Databázové systémy. Vybrané kapitoly a cvičení. Karolinum,
Praha, 1993.
Pokorný, J., Halaška, I.: Databázové systémy. Vybrané kapitoly a cvičení. Karolinum –
nakladatelství Univerzity Karlovy, Praha, 1998.
Richta, K., Sochor, J.: Projektování programových systémů. ČVUT FEL, Praha, 1994.
Riordan, R.: Designing Effective Database Systems. Addison-Wesley Professional,
2005. ISBN 0321290933.
Rob, P. and Coronel, C.M.: Database Systems: Design, Implementation and
Management. Course Technology, 2004. ISBN 061921323X.
Shah, N.: Database Systems Using Oracle. Prentice Hall, 2004. ISBN 0131018574.
Straka, M.: Vývoj databázových aplikací. Grada, Praha, 1992.
79
[29]
[30]
[31]
[32]
Šimůnek, M.: SQL - kompletní kapesní průvodce. Grada, Praha, 1999.
Ullman, L.: PHP a MySQL. Computer Press, Brno, 2004.
Viescas, J.: Mistrovství v Microsoft Access 2000. Computer Press, Praha, 2000.
Williams, H.E., Lane, D.: PHP a MySQL. Vytváříme webové databázové aplikace.
Computer Press, Praha, 2002.
80
Terminology
A
aggregation function
argument
Armstrong’s axioms
assignment statement
attribute
augmentation rule
agregační funkce
argument, parametr (procedury/funkce)
Armstrongovy axiomy
přiřazovací příkaz
atribut
pravidlo zvětšení
B
batch processing
Boyce-Codd normal form
zpracování v dávkách
Boyce-Coddova normální forma (BCNF)
C
Cartesian product
check box
closure
collection
combo box control
command button
completeness
conditional statement
consistency
controls
crosstab query
kartézský součin
zaškrtávací pole (= ano/ne)
uzávěr
kolekce
pole se seznamem
příkazové tlačítko
úplnost
podmíněný příkaz
konzistence
řídící prvky (např. ve formulářích)
křížový dotaz
D
DAO
data mining
data model
database
database design
DBMS
DDL
DFD
DML
decision making
decomposition theorem
degree
deletion anomaly
division
domain
Data Access Objects
dolování dat
datový model
databáze
návrh datových struktur
Database Management System
Data Definition Language
Data Flow Diagram
Data Manipulation Language
rozhodování
dekompoziční teorém, věta o rozkladu
řád, stupeň
anomálie zrušení
dělení
doména, obor hodnot
81
E
entity
E-R diagram
event procedure
expression
entita, objekt (reálného světa)
Entity-Relationship diagram
událostní procedura
výraz
F
field
filtering
first normal form
foreign key
fourth normal form
form
function
functional dependency
pole, položka
filtrování
1. normální forma (1NF)
cizí klíč
formulář
funkce
funkční závislost
G
H
heap
hierarchical data model
halda, hromada
hierarchický datový model
I
inclusion rule
inconsistency
independence
index (file)
inference rules
insertion anomaly
integrity constraints
intersection
pravidlo inkluze
nekonzistence
nezávislost
index(ový soubor)
odvozovací pravidla
anomálie vložení
integritní omezení
průnik
J
join operation
jump statement
operace spojení
příkaz skoku
K
key attribute
klíčový atribut, klíč
L
list box control
seznam
82
loop statement
lossless decomposition
příkaz cyklu
bezeztrátový rozklad
M
many-to-many relationship
multivalued functional dependency
relace M:N
multizávislost
N
natural join operation
normal form
operace přirozeného spojení
normální forma
O
object
ODBC
one-to-many relationship
one-to-one relationship
object
Open Database Connectivity
relace 1:N
relace 1:1
P
partial functional dependency
primary key
procedure
projection
částečná funkční závislost
primární klíč
procedura
projekce
Q
query
dotaz
R
radio button (option group control)
recordset
redundancy
reference integrity
relation
relational algebra
relational calculus
relational data model
relational scheme
relationship
report
přepínač
recordset, množina záznamů
redundance, nadbytečnost
referenční integrita
relace
relační algebra
relační kalkul
relační datový model
relační schéma
vztah
sestava
S
subquery
subroutine
poddotaz
podprogram
83
sharing
searching
second normal form
selection
snapshot
soundness
sorting
SQL
sdílení
hledání, vyhledávání
výběr
snímek
bezespornost
řazení, uspořádávání (podle velikosti, abecedy)
Structured Query Language
T
table
textbox control
third normal form
transaction
transitivity rule
transitive closure
transitive functional dependency
tuple
tabulka
textové pole
transakce
pravidlo tranzitivity
tranzitivní uzávěr
tranzitivní funkční závislost
n-tice
U
union
update
user-defined data type
sjednocení
aktualizovat
uživatelem definovaný datový typ
V
validation rule
VBA
ověřovací pravidlo
Visual Basic for Applications
W
workspace
pracovní oblast
84

1.2 Database Systems

Transkript

Podobné dokumenty

DesignMyLove_katalog

prezentace 2015 - a3, 1-4, 2-3 england - Jean

Healthy Meetings_BRNO_EN.indd