I try to compiled this guide for Acer 4520 users, some variants of this model may work with this tips, the other may not, hope you the lucky number one . This guide below I write in Indonesian, sorry for disappointing you, because lacks of guide about this issues in Indonesian.
http://sty-thehybrid.blogspot.com/2008/03/installing-ubuntu-710-aka-gutsy-gibbon.html
Sty - Knowledge is Free
Read More..
Showing posts with label Tutorial. Show all posts
Showing posts with label Tutorial. Show all posts
One term you can't go far into databases without encountering is SQL, which stands for Structured Query Language. SQL is the language used to retrieve, add, modify, and delete records in databases. Let's look at each of these features in turn.
By the Way
Incidentally, the pronunciation of SQL is somewhat of a contentious issue. The official party line is that SQL should be pronounced "es queue el." However, many people opt for the more casual and also more efficient pronunciation, "sequel." Count me in the latter camp!
Retrieving Records Using SELECT
Just about everything in SQL is carried out via a query, which is simply the act of communicating with the database according to an established set of SQL commands. The query used to retrieve data from a database is called the SELECT statement. It has several parts, not all of which are mandatory. The most basic SELECT statement is composed of two partsthe select list and the FROM clause. A very simple SELECT statement looks like this:
SELECT * FROM students
Following are the database records returned as the results of the query:
+-------------+-----------------+--------------------+-------+----------------+---------+
| id_students | student_name | city | state | classification | tuition |
+-------------+-----------------+--------------------+-------+----------------+---------+
| 1 | Franklin Pierce | Hillsborough | NH | senior | 5000 |
| 2 | James Polk | Mecklenburg County | NC | freshman | 11000 |
| 2 | Warren Harding | Marion | OH | junior | 3500 |
+-------------+-----------------+--------------------+-------+----------------+---------+
In this case, the * is the select list. The select list indicates which database columns should be included in the query results. When a * is supplied, it indicates that all of the columns in the table or tables listed in the FROM clause should be included in the query results.
The FROM clause contains the list of tables from which the data will be retrieved. In this case, the data is retrieved from just one table, students. I'll explain how to retrieve data from multiple tables in a bit.
Let's go back to the select list. If you use a select list that isn't simply *, you include a list of column names separated by commas. You can also rename columns in the query results (useful in certain situations), using the AS keyword, as follows:
SELECT id_students AS id, student_name, state
FROM students
As the results show, only the student name and state columns are returned for the records:
+------+-----------------+-------+
| id | student_name | state |
+------+-----------------+-------+
| 1 | Franklin Pierce | NH |
| 2 | James Polk | NC |
| 2 | Warren Harding | OH |
+------+-----------------+-------+
The id_students column is renamed id in the query results using the reserved word 'AS'. The other keyword you'll often use in a select statement is DISTINCT. When you include DISTINCT at the beginning of a select statement, it indicates that no duplicates should be included in the query results. Here's a sample query:
SELECT DISTINCT city
FROM students
And here are the results:
+--------------------+
| city |
+--------------------+
| Hillsborough |
| Mecklenburg County |
| Marion |
+--------------------+
Without DISTINCT, this query would return the city of every student in the students table. In this case, it returns only the distinct values in the table, regardless of how many of each of them there are. In this case, there are only three records in the table and each of them has a unique city, so the result set is the same as it would be if DISTINCT were left off.
The WHERE Clause
Both of the previous queries simply return all of the records in the students table. Often, you'll want to constrain the resultset so that it returns only those records you're actually interested in. The WHERE clause is used to specify which records in a table should be included in the results of a query. Here's an example:
SELECT student_name
FROM students
WHERE id_students = 1
Only the record with the matching ID is returned in the results:
+-----------------+
| student_name |
+-----------------+
| Franklin Pierce |
+-----------------+
When you use the WHERE clause, you must include an expression that filters the query results. In this case, the expression is very simple. Given that id_students is the primary key for this table, this query is sure to return only one row. You can use other comparison operators as well, like the > or != operators. It's also possible to use Boolean operators to create compound expressions. For example, you can retrieve all of the students who pay more than $10,000 per year in tuition and who are classified as freshmen using the following query:
SELECT student_name
FROM students
WHERE tuition > 10000
AND classification = 'freshman'
Following are the results of this query:
+--------------+
| student_name |
+--------------+
| James Polk |
+--------------+
There are also several other functions you can use in the WHERE clause that enable you to write more powerful queries. The LIKE function allows you to search for fields containing a particular string using a regular expression like syntax. The BETWEEN function allows you to search for values between the two you specify, and IN allows you to test whether a value is a member of a set you specify.
By the Way
Because the goal in this hour is ultimately to learn how to use XML with databases, I won't go into any more detail on these query functions, but feel free to do some additional SQL learning online at http://www.w3schools.com/sql/default.asp, or pick up a book on SQL. Fortunately, you don't have to be a SQL guru to get the benefits of this lesson.
Inserting Records
The INSERT statement is used to insert records into a table. The syntax is simple, especially if you plan on populating every column in a table. To insert a record into majors, use the following statement:
INSERT INTO majors
VALUES (115, 50, 'Math', 'English')
The values in the list correspond to the id_majors, id_students, major, and minor columns respectively. If you only want to specify values for a subset of the columns in the table, you must specify the names of the columns as well, as in the following:
INSERT INTO students
(id_students, student_name)
VALUES (50, 'Milton James')
When you create tables, you can specify whether values are required in certain fields, and you can also specify default values for fields. For example, the classification column might default to freshman because most new student records being inserted will be for newly enrolled students, who are classified as freshmen.
Updating Records
When you want to modify one or more records in a table, the UPDATE statement is used. Here's an example:
UPDATE students
SET classification = 'senior'
The previous SQL statement will work, but I bet you can figure out what's wrong with it. Nowhere is it specified which records to update. If you don't tell it which records to update, it just assumes that you want to update all of the records in the table, thus the previous query would turn all of the students into seniors. That's probably not what you have in mind. Fortunately, the UPDATE statement supports the WHERE clause, just like the SELECT statement.
UPDATE students
SET classification = 'senior'
WHERE id_students = 1
That's more like it. This statement updates the classification of only one student. You can also update multiple columns with one query, as in the following:
UPDATE students
SET classification = 'freshman', tuition = 7500
WHERE id_students = 5
As you can see from the example, you can supply a list of fields to update with your UPDATE statement, and they will all be updated by the same query.
Deleting Records
The last SQL statement I'll discuss is the DELETE statement, which is similar to the UPDATE statement. It accepts a FROM clause, and optionally a WHERE clause. If you leave out the WHERE clause, it deletes all the records in the table. Here's an example:
DELETE FROM students
WHERE id_students = 1
You now know just enough about SQL to get into trouble! Actually, your newfound SQL knowledge will come in handy a bit later in the lesson when you develop an application that carefully extracts data from a database and encodes it in XML. But first, you find out how to export an entire database table as XML.
Sty - Knowledge is Free
Read More..
By the Way
Incidentally, the pronunciation of SQL is somewhat of a contentious issue. The official party line is that SQL should be pronounced "es queue el." However, many people opt for the more casual and also more efficient pronunciation, "sequel." Count me in the latter camp!
Retrieving Records Using SELECT
Just about everything in SQL is carried out via a query, which is simply the act of communicating with the database according to an established set of SQL commands. The query used to retrieve data from a database is called the SELECT statement. It has several parts, not all of which are mandatory. The most basic SELECT statement is composed of two partsthe select list and the FROM clause. A very simple SELECT statement looks like this:
SELECT * FROM students
Following are the database records returned as the results of the query:
+-------------+-----------------+--------------------+-------+----------------+---------+
| id_students | student_name | city | state | classification | tuition |
+-------------+-----------------+--------------------+-------+----------------+---------+
| 1 | Franklin Pierce | Hillsborough | NH | senior | 5000 |
| 2 | James Polk | Mecklenburg County | NC | freshman | 11000 |
| 2 | Warren Harding | Marion | OH | junior | 3500 |
+-------------+-----------------+--------------------+-------+----------------+---------+
In this case, the * is the select list. The select list indicates which database columns should be included in the query results. When a * is supplied, it indicates that all of the columns in the table or tables listed in the FROM clause should be included in the query results.
The FROM clause contains the list of tables from which the data will be retrieved. In this case, the data is retrieved from just one table, students. I'll explain how to retrieve data from multiple tables in a bit.
Let's go back to the select list. If you use a select list that isn't simply *, you include a list of column names separated by commas. You can also rename columns in the query results (useful in certain situations), using the AS keyword, as follows:
SELECT id_students AS id, student_name, state
FROM students
As the results show, only the student name and state columns are returned for the records:
+------+-----------------+-------+
| id | student_name | state |
+------+-----------------+-------+
| 1 | Franklin Pierce | NH |
| 2 | James Polk | NC |
| 2 | Warren Harding | OH |
+------+-----------------+-------+
The id_students column is renamed id in the query results using the reserved word 'AS'. The other keyword you'll often use in a select statement is DISTINCT. When you include DISTINCT at the beginning of a select statement, it indicates that no duplicates should be included in the query results. Here's a sample query:
SELECT DISTINCT city
FROM students
And here are the results:
+--------------------+
| city |
+--------------------+
| Hillsborough |
| Mecklenburg County |
| Marion |
+--------------------+
Without DISTINCT, this query would return the city of every student in the students table. In this case, it returns only the distinct values in the table, regardless of how many of each of them there are. In this case, there are only three records in the table and each of them has a unique city, so the result set is the same as it would be if DISTINCT were left off.
The WHERE Clause
Both of the previous queries simply return all of the records in the students table. Often, you'll want to constrain the resultset so that it returns only those records you're actually interested in. The WHERE clause is used to specify which records in a table should be included in the results of a query. Here's an example:
SELECT student_name
FROM students
WHERE id_students = 1
Only the record with the matching ID is returned in the results:
+-----------------+
| student_name |
+-----------------+
| Franklin Pierce |
+-----------------+
When you use the WHERE clause, you must include an expression that filters the query results. In this case, the expression is very simple. Given that id_students is the primary key for this table, this query is sure to return only one row. You can use other comparison operators as well, like the > or != operators. It's also possible to use Boolean operators to create compound expressions. For example, you can retrieve all of the students who pay more than $10,000 per year in tuition and who are classified as freshmen using the following query:
SELECT student_name
FROM students
WHERE tuition > 10000
AND classification = 'freshman'
Following are the results of this query:
+--------------+
| student_name |
+--------------+
| James Polk |
+--------------+
There are also several other functions you can use in the WHERE clause that enable you to write more powerful queries. The LIKE function allows you to search for fields containing a particular string using a regular expression like syntax. The BETWEEN function allows you to search for values between the two you specify, and IN allows you to test whether a value is a member of a set you specify.
By the Way
Because the goal in this hour is ultimately to learn how to use XML with databases, I won't go into any more detail on these query functions, but feel free to do some additional SQL learning online at http://www.w3schools.com/sql/default.asp, or pick up a book on SQL. Fortunately, you don't have to be a SQL guru to get the benefits of this lesson.
Inserting Records
The INSERT statement is used to insert records into a table. The syntax is simple, especially if you plan on populating every column in a table. To insert a record into majors, use the following statement:
INSERT INTO majors
VALUES (115, 50, 'Math', 'English')
The values in the list correspond to the id_majors, id_students, major, and minor columns respectively. If you only want to specify values for a subset of the columns in the table, you must specify the names of the columns as well, as in the following:
INSERT INTO students
(id_students, student_name)
VALUES (50, 'Milton James')
When you create tables, you can specify whether values are required in certain fields, and you can also specify default values for fields. For example, the classification column might default to freshman because most new student records being inserted will be for newly enrolled students, who are classified as freshmen.
Updating Records
When you want to modify one or more records in a table, the UPDATE statement is used. Here's an example:
UPDATE students
SET classification = 'senior'
The previous SQL statement will work, but I bet you can figure out what's wrong with it. Nowhere is it specified which records to update. If you don't tell it which records to update, it just assumes that you want to update all of the records in the table, thus the previous query would turn all of the students into seniors. That's probably not what you have in mind. Fortunately, the UPDATE statement supports the WHERE clause, just like the SELECT statement.
UPDATE students
SET classification = 'senior'
WHERE id_students = 1
That's more like it. This statement updates the classification of only one student. You can also update multiple columns with one query, as in the following:
UPDATE students
SET classification = 'freshman', tuition = 7500
WHERE id_students = 5
As you can see from the example, you can supply a list of fields to update with your UPDATE statement, and they will all be updated by the same query.
Deleting Records
The last SQL statement I'll discuss is the DELETE statement, which is similar to the UPDATE statement. It accepts a FROM clause, and optionally a WHERE clause. If you leave out the WHERE clause, it deletes all the records in the table. Here's an example:
DELETE FROM students
WHERE id_students = 1
You now know just enough about SQL to get into trouble! Actually, your newfound SQL knowledge will come in handy a bit later in the lesson when you develop an application that carefully extracts data from a database and encodes it in XML. But first, you find out how to export an entire database table as XML.
Sty - Knowledge is Free
Before an application can read an XML document, it must learn what XML markup tags the document uses. It does this by reviewing the document type definition (DTD). A valid document includes a document type declaration that identifies the DTD the document satisfies. The DTD lists all the elements, attributes, and entities the document uses and the contexts in which it uses them.
Creating Your Own Markup Languages
When you create an XML document, you aren't really using XML to code the document. Instead, you are using a markup language that was created in XML. In other words, XML is used to create markup languages that are then used to create XML documents.
When you create your own markup language, you are basically establishing which elements (tags) and attributes are used to create documents in that language. Not only is it important to fully describe the different elements and attributes, but you must also describe how they relate to one another.
Creating Your First DTD
A DTD can be declared inline inside an XML document, or as an external reference.
Internal DTD Declaration
If the DTD is declared inside the XML file, it should be wrapped in a DOCTYPE definition with the following syntax:
<!DOCTYPE root-element [element-declarations]>
Example XML document with an internal DTD:
<?xml version="1.0"?>
<!DOCTYPE note [
<!ELEMENT note (to,from,heading,body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>
]>
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend</body>
</note>
The DTD above is interpreted like this:
!DOCTYPE note defines that the root element of this document is note.
!ELEMENT note defines that the note element contains four elements: "to,from,heading,body".
!ELEMENT to defines the to element to be of the type "#PCDATA".
!ELEMENT from defines the from element to be of the type "#PCDATA".
!ELEMENT heading defines the heading element to be of the type "#PCDATA".
!ELEMENT body defines the body element to be of the type "#PCDATA".
External DTD Declaration
If the DTD is declared in an external file, it should be wrapped in a DOCTYPE definition with the following syntax:
<!DOCTYPE root-element SYSTEM "filename">
This is the same XML document as above, but with an external DTD (Open it, and select view source):
<?xml version="1.0"?>
<!DOCTYPE note SYSTEM "note.dtd">
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>
And this is the file "note.dtd" which contains the DTD:
<!ELEMENT note (to,from,heading,body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>
As you know by now, the goal of most XML documents is to be valid. Document validity is extremely important because it guarantees that the data within a document conforms to a standard set of guidelines as laid out in a schema (DTD or XSD).
An XML application can certainly determine if a document is well formed without any other information, but it requires a schema in order to assess document validity. This schema typically comes in the form of a DTD (Document Type Definition) or XSD (XML Schema Definition), which you learned about in next article.
To recap, schemas allow you to establish the following ground rules that XML documents must adhere to in order to be considered valid:
- Establish the elements that can appear in an XML document, along with the attributes that can be used with each
- Determine whether an element is empty or contains content (text and/or child elements)
- Determine the number and sequence of child elements within an element
- Set the default value for attributes
Sty - Knowledge is Free
Read More..
Creating Your Own Markup Languages
When you create an XML document, you aren't really using XML to code the document. Instead, you are using a markup language that was created in XML. In other words, XML is used to create markup languages that are then used to create XML documents.
When you create your own markup language, you are basically establishing which elements (tags) and attributes are used to create documents in that language. Not only is it important to fully describe the different elements and attributes, but you must also describe how they relate to one another.
Creating Your First DTD
A DTD can be declared inline inside an XML document, or as an external reference.
Internal DTD Declaration
If the DTD is declared inside the XML file, it should be wrapped in a DOCTYPE definition with the following syntax:
<!DOCTYPE root-element [element-declarations]>
Example XML document with an internal DTD:
<?xml version="1.0"?>
<!DOCTYPE note [
<!ELEMENT note (to,from,heading,body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>
]>
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend</body>
</note>
The DTD above is interpreted like this:
!DOCTYPE note defines that the root element of this document is note.
!ELEMENT note defines that the note element contains four elements: "to,from,heading,body".
!ELEMENT to defines the to element to be of the type "#PCDATA".
!ELEMENT from defines the from element to be of the type "#PCDATA".
!ELEMENT heading defines the heading element to be of the type "#PCDATA".
!ELEMENT body defines the body element to be of the type "#PCDATA".
External DTD Declaration
If the DTD is declared in an external file, it should be wrapped in a DOCTYPE definition with the following syntax:
<!DOCTYPE root-element SYSTEM "filename">
This is the same XML document as above, but with an external DTD (Open it, and select view source):
<?xml version="1.0"?>
<!DOCTYPE note SYSTEM "note.dtd">
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>
And this is the file "note.dtd" which contains the DTD:
<!ELEMENT note (to,from,heading,body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>
As you know by now, the goal of most XML documents is to be valid. Document validity is extremely important because it guarantees that the data within a document conforms to a standard set of guidelines as laid out in a schema (DTD or XSD).
An XML application can certainly determine if a document is well formed without any other information, but it requires a schema in order to assess document validity. This schema typically comes in the form of a DTD (Document Type Definition) or XSD (XML Schema Definition), which you learned about in next article.
To recap, schemas allow you to establish the following ground rules that XML documents must adhere to in order to be considered valid:
- Establish the elements that can appear in an XML document, along with the attributes that can be used with each
- Determine whether an element is empty or contains content (text and/or child elements)
- Determine the number and sequence of child elements within an element
- Set the default value for attributes
Sty - Knowledge is Free
XML Programming - Introduction to XML Programming
Posted In:
DTD
,
HTML
,
Internet
,
Intro
,
Introduction
,
Markup Language
,
Tutorial
,
Web
,
Web Programming
,
XML
.
By Shun
What is XML?
The following points can explain the purpose of XML.
- XML stands for eXtensible Markup Language
- XML is a markup language much like HTML.
- XML was designed to describe data.
- XML tags are not predefined in XML. You must define your own tags.
- XML uses a DTD (Document Type Definition) to describe the data.
- XML with a DTD is designed to be self describing.
It is important to understand that XML is not a replacement for HTML. The main purpose of HTML is the Format the Data that is presented through Browser. The purpose of XML is not to Format the Data to be displayed. It's mostly used to store and transfer data and to describe the data. It is device or language independent and can be used for Transmitting Data to any device. The Parser (Or the Program which is capable of understanding the Tags and returning the Text in a Valid Format) on the corresponding device will help in displaying the data in required format.
You can define your own tags in XML file. The way these tags will be interpreted will depend on the program which is going to get this XML file. The data embedded within these tags will be used according to logic implemented in the secondary program which is going to get this XML as feed. This point will be clearer when we start explaining you about how to use the Parsers in next few paragraphs.
XML Declarations
Most of the XML tags have a name associated with it. Here we explain different terms used to indicate the Elements defined in the XML file.
Well Formed Tags:
One of the most important features of a XML file is it should be a Well Formed File. What it means is all the tags should have a closing tag. In a HTML file, for some tags like <br> we don't have to specify a closing tag called </br>. Where as in a XML file, it is compulsory to have a closing tag. So we have to declare <br></br> or <br/>. This are what called as Well Formed Tags.
Elements and Attributes:
Each tag in a XML file can have elements and attributes. Here's how a typical tag looks like.
|
|
In this example, Email is called as Element. This element called Email has three attributes, to, from and subject.
The Following Rules need to be followed while declaring the XML Elements Names:
- Names can contain letters, numbers, and other characters
- Names must not start with a number or "_" (underscore)
- Names must not start with the letters xml (or XML or Xml ..)
- Names can not contain spaces
Any name can be used, no words are reserved, but the idea is to make names descriptive. Names with an underscore separator are nice.
Examples: <author_name>, <published_date>
Avoid "-" and "." in names. It could be a mess if your software tried to subtract name from first (author-name) or think that "name" is a property of the object "author" (author.name).
Element names can be as long as you like, but don't exaggerate. Names should be short and simple, like this: <author_name>
XML documents often have a parallel database, where fieldnames parallel with element names. A good rule is to use the naming rules of your databases.
Non-English letters like éòá are perfectly legal in XML element names, but watch out for problems if your software vendor doesn't support it.
The ":" should not be used in element names because it is reserved to be used for something called namespaces.
Empty Tags:
In cases where you don't have to provide any sub tags, you can close the tag, by providing a "/" to the Closing Tag. For example declaring
| |
Comments in XML file are declared the same way as Comments in HTML File.
|
XML file always starts with a prolog. The minimal prolog contains a declaration that identifies the document as an XML document, like this:
<?xml version="1.0"?>
The declaration may also contain additional information, like this:
<?xml version="1.0" encoding="ISO-8859-1" standalone="yes"?>
The XML declaration may contain the following attributes:
version
Identifies the version of the XML markup language used in the data. This attribute is not optional.
encoding
Identifies the character set used to encode the data. "ISO-8859-1" is "Latin-1" the Western European and English language character set. (The default is compressed Unicode: UTF-8.).
standalone
Tells whether or not this document references an external entity or an external data type specification (see below). If there are no external references, then "yes" is appropriate.
Sty - Knowledge is Free
