Date post: | 30-Dec-2015 |
Category: |
Documents |
Upload: | ursula-moreno |
View: | 28 times |
Download: | 0 times |
1
Announcements
Reading for next week: 2 papers available on Blackboard Background Reading: 1.11, 12.1-12.8 in text
About homework assignment 1 ...
Plan for Today
Review of Database Design, Functional Dependency, and Normal Forms
Choices for Application Design
XML (briefly)
3
Database Design
What’s the problem here? Entity-Relationship Model (and Diagrams) Functional Dependencies
Legal relations Decompositions Closures and Canonical Covers Dependency Preservation
Normal Forms 1st Normal Form Boyce-Codd Normal Form (BCNF) 3rd Normal Form
Application Design
Application Design
What’s the Big Question/Problem in Application Design? In other words, why are we studying this?
Client Side Scripting and Applets Browsers can fetch certain scripts (client-side scripts) or
programs along with documents, and execute them in “safe mode” at the client site Javascript Macromedia Flash and Shockwave for animation/games VRML Applets
Client-side scripts/programs allow documents to be active E.g., animation by executing programs at the local site E.g. ensure that values entered by users satisfy some
correctness checks Permit flexible interaction with the user.
Executing programs at the client site speeds up interaction by avoiding many round trips to server
Client Side Scripting and Security
Security mechanisms needed to ensure that malicious scripts do not cause damage to the client machine Easy for limited capability scripting languages, harder
for general purpose programming languages like Java
E.g. Java’s security system ensures that the Java applet code does not make any system calls directly Disallows dangerous actions such as file writes Notifies the user about potentially dangerous actions,
and allows the option to abort the program or to continue execution.
Web Servers A Web server can easily serve as a front end to a variety
of information services. The document name in a URL may identify an executable
program, that, when run, generates a HTML document. When a HTTP server receives a request for such a document, it
executes the program, and sends back the HTML document that is generated.
The Web client can pass extra arguments with the name of the document.
To install a new service on the Web, one simply needs to create and install an executable that provides that service. The Web browser provides a graphical user interface to the
information service. Common Gateway Interface (CGI): a standard interface
between web and application server
HTTP and Sessions The HTTP protocol is connectionless
That is, once the server replies to a request, the server closes the connection with the client, and forgets all about the request
In contrast, Unix logins, and JDBC/ODBC connections stay connected until the client disconnects retaining user authentication and other information
Motivation: reduces load on server operating systems have tight limits on number of open
connections on a machine Information services need session information
E.g. user authentication should be done only once per session
Solution: use a cookie
Sessions and Cookies A cookie is a small piece of text containing
identifying information Sent by server to browser on first interaction Sent by browser to the server that created the
cookie on further interactions part of the HTTP protocol
Server saves information about cookies it issued, and can use it when serving a request E.g., authentication information, and user preferences
Cookies can be stored permanently or for a limited time
Three-Tier Web Architecture
Two-Tier Web Architecture
Servlets Java Servlet specification defines an API for communication
between the Web server and application program E.g. methods to get parameter values and to send HTML text back to
client
Application program (also called a servlet) is loaded into the Web server Two-tier model Each request spawns a new thread in the Web server
thread is closed once the request is serviced
Servlet API provides a getSession() method Sets a cookie on first interaction with browser, and uses it to identify
session on further interactions Provides methods to store and look-up per-session information
E.g. user name, preferences, ..
Example Servlet Code
public class BankQueryServlet extends HttpServlet
{public void doGet(HttpServletRequest request, HttpServletResponse result)
throws ServletException, IOException
{
String type = request.getParameter(“type”);String number = request.getParameter(“number”);
…code to find the loan amount/account balance … …using JDBC to communicate with the database.. …we assume the value is stored in the variable balance
result.setContentType(“text/html”);PrintWriter out = result.getWriter( );out.println(“<HEAD><TITLE>Query Result</TITLE></HEAD>”);out.println(“<BODY>”);out.println(“Balance on “ + type + number + “=“ + balance);out.println(“</BODY>”);out.close ( );
}
}
Server-Side Scripting Server-side scripting simplifies the task of connecting a
database to the Web Define a HTML document with embedded executable code/SQL
queries. Input values from HTML forms can be used directly in the
embedded code/SQL queries. When the document is requested, the Web server executes the
embedded code/SQL queries to generate the actual HTML document.
Numerous server-side scripting languages JSP, Server-side Javascript, ColdFusion Markup Language
(cfml), PHP, Jscript General purpose scripting languages: VBScript, Perl, Python
Comparative Advantages
JDBC and ODBC from Client Positive: Negative:
Client-side Scripting and Applets Positive: Negative:
Three-Tier Server Architecture Positive: Negative:
Two-Tier Server Architecture Positive: Negative:
Server-Side Scripting Positive: Negative:
eXtensible Markup Language (XML)
XML: Motivation Data interchange is critical in today’s networked
world Examples:
Banking: funds transfer Order processing (especially inter-company orders) Scientific data
Chemistry: ChemML, … Genetics: BSML (Bio-Sequence Markup Language), …
Paper flow of information between organizations is being replaced by electronic flow of information
Each application area has its own set of standards for representing information
XML has become the basis for all new generation data interchange formats
XML Motivation (Cont.) Earlier generation formats were based on plain text with
line headers indicating the meaning of fields Similar in concept to email headers Does not allow for nested structures, no standard “type” language Tied too closely to low level document structure (lines, spaces,
etc) Each XML based standard defines what are valid
elements, using XML type specification languages to specify the syntax
DTD (Document Type Descriptors) XML Schema
Plus textual descriptions of the semantics XML allows new tags to be defined as required
However, this may be constrained by DTDs A wide variety of tools is available for parsing, browsing
and querying XML documents/data
Comparison with Relational Data Inefficient: tags, which in effect represent
schema information, are repeated Better than relational tuples as a data-
exchange format Unlike relational tuples, XML data is self-
documenting due to presence of tags Non-rigid format: tags can be added Allows nested structures Wide acceptance, not only in database systems,
but also in browsers, tools, and applications
Structure of XML Data
Tag: label for a section of data Element: section of data beginning with <tagname> and
ending with matching </tagname> Elements must be properly nested
Proper nesting <account> … <balance> …. </balance> </account>
Improper nesting <account> … <balance> …. </account> </balance>
Formally: every start tag must have a unique matching end tag, that is in the context of the same parent element.
Every document must have a single top-level element
XML Example
<bank> <account>
<account_number> A-101 </account_number> <branch_name> Downtown </branch_name> <balance> 500 </balance>
</account> <depositor>
<account_number> A-101 </account_number> <customer_name> Johnson </customer_name>
</depositor> </bank>
XML Document Schema
Database schemas constrain what information can be stored, and the data types of stored values
XML documents are not required to have an associated schema
However, schemas are very important for XML data exchange Otherwise, a site cannot automatically interpret data received
from another site Two mechanisms for specifying XML schema
Document Type Definition (DTD) Widely used
XML Schema Newer, increasing use
Document Type Definition (DTD) The type of an XML document can be specified using a DTD
DTD constraints structure of XML data What elements can occur What attributes can/must an element have What subelements can/must occur inside each element, and how many
times.
DTD does not constrain data types All values represented as strings in XML
DTD syntax <!ELEMENT element (subelements-specification) > <!ATTLIST element (attributes) >
Element Specification in DTD
Subelements can be specified as names of elements, or #PCDATA (parsed character data), i.e., character strings EMPTY (no subelements) or ANY (anything can be a subelement)
Example
<! ELEMENT depositor (customer_name account_number)> <! ELEMENT customer_name (#PCDATA)>
<! ELEMENT account_number (#PCDATA)> Subelement specification may have regular expressions
<!ELEMENT bank ( ( account | customer | depositor)+)> Notation:
“|” - alternatives “+” - 1 or more occurrences “*” - 0 or more occurrences
Bank DTD
<!DOCTYPE bank [<!ELEMENT bank ( ( account | customer | depositor)+)><!ELEMENT account (account_number branch_name balance)><! ELEMENT customer(customer_name customer_street customer_city)><! ELEMENT depositor (customer_name account_number)><! ELEMENT account_number (#PCDATA)><! ELEMENT branch_name (#PCDATA)><! ELEMENT balance(#PCDATA)><! ELEMENT customer_name(#PCDATA)><! ELEMENT customer_street(#PCDATA)><! ELEMENT customer_city(#PCDATA)>
]>
Limitations of DTDs
No typing of text elements and attributes All values are strings, no integers, reals, etc.
Difficult to specify unordered sets of subelements Order is usually irrelevant in databases (unlike in the document-
layout environment from which XML evolved) (A | B)* allows specification of an unordered set, but
Cannot ensure that each of A and B occurs only once
IDs and IDREFs are untyped The owners attribute of an account may contain a reference to
another account, which is meaningless owners attribute should ideally be constrained to refer to customer
elements
XML Schema
XML Schema is a more sophisticated schema language which addresses the drawbacks of DTDs. Supports Typing of values
E.g. integer, string, etc Also, constraints on min/max values
User-defined, comlex types Many more features, including
uniqueness and foreign key constraints, inheritance
XML Schema is itself specified in XML syntax, unlike DTDs More-standard representation, but verbose
XML Scheme is integrated with namespaces
BUT: XML Schema is significantly more complicated than DTDs.
XML Schema Version of Bank DTD<xs:schema xmlns:xs=http://www.w3.org/2001/XMLSchema>
<xs:element name=“bank” type=“BankType”/>
<xs:element name=“account”><xs:complexType> <xs:sequence> <xs:element name=“account_number” type=“xs:string”/> <xs:element name=“branch_name” type=“xs:string”/> <xs:element name=“balance” type=“xs:decimal”/> </xs:squence></xs:complexType>
</xs:element>….. definitions of customer and depositor ….
<xs:complexType name=“BankType”><xs:squence>
<xs:element ref=“account” minOccurs=“0” maxOccurs=“unbounded”/>
<xs:element ref=“customer” minOccurs=“0” maxOccurs=“unbounded”/>
<xs:element ref=“depositor” minOccurs=“0” maxOccurs=“unbounded”/>
</xs:sequence></xs:complexType></xs:schema>
Where we are in the course … Fundamentals of Using a Database
Relational Model SQL Database Design Application Design
Implementing a Database System Architecture Storage Structure and Indexing Query Processing and Optimization Transactions
Data Mining and Databases Pattern and Association Mining Information Retrieval