YOUR WEBSITE

Temporal Data Types

2012-02-11T11:18:00.000-08:00

Date and time data types are referred to as temporal data types. MySQL provides data types for storing different kinds of temporal information. In the following descriptions, the terms YYYY, MM, DD, hh, mm, and ss stand for a year, month, day of month, hour, minute, and second value, respectively.

String Data Types

2012-02-11T09:37:00.000-08:00

A string data type is a data type modeled on the idea of a formal string. They are commonly used to store text or binary data. Types are available to hold values of varying maximum lengths and can be chosen according to if the values are to be treated as text, binary or integer. Strings are such an important and useful data type that they are implemented in nearly every programming language.

Text String Type Summary

For the storage requirement values, M represents the maximum length of a column. L represents the actual length of a given value, which may be 0 to M.

CHAR( ) A fixed section from 0 to 255 characters long.
VARCHAR( ) A variable section from 0 to 255 characters long.
TINYTEXT A string with a maximum length of 255 characters.
TEXT A string with a maximum length of 65535 characters.
MEDIUMTEXT A string with a maximum length of 16777215 characters.
LONGTEXT A string with a maximum length of 4294967295 characters.

Binary String Type Summary

For the storage requirement values, M represents the maximum length of a column. L represents the actual length of a given value, which may be 0 to M.

Integer Values

Numeric Data Type

2012-02-09T22:42:00.000-08:00

For storing numeric data, MySQL provides integer data types, floating-point types that store approximate-value (real) numbers, a fixed-point type that stores exact-value (real) numbers, and a BIT type for bit-field values. When numeric data type is chosen, consider the following factors:

• The range of values the data type represents

• The amount of storage space that column values require

• The column precision and scale for floating-point and fixed-point values

Precision and scale are terms that apply to floating-point and fixed-point values, which can have both an integer part and a fractional part. Precision is the number of significant digits. Scale is the number of digits to the right of the decimal point.

Integer Data Type

The integer data types are summarized in the following table, which indicates the amount of storage per value that each type requires as well as its ra nge. For integer values declared with the UNSIGNED attribute, negative values are not allowed, and the high end of the range shifts upward to approximately double the maximum positive value of the signed range.

Type	Storage Required	Signed Range	Unsigned Range
TINYINT	1 byte	–128 to 127	0 to 255
SMALLINT	2 bytes	–32,768 to 32,767	0 to 65,535
MEDIUMINT	3 bytes	–8,388,608 to 8,388,607	0 to 16,777,215
INT	4 bytes	–2,147,683,648 to 2,147,483,647	0 to 4,294,967,295
BIGINT	8 bytes	–9,223,372,036,854,775,808 to 9,223,372,036,854,775,807	0 to 18,446,744,073,709,551,615

Floating-Point Types

The floating-point data types include FLOAT and DOUBLE. Each of these types may be used to represent approximate-value numbers that have an integer part, a fractional part, or both. FLOAT and DOUBLE data types represent values in the native binary floating-point format (IEEE 754) used by the server host's CPU. This is a very efficient type for storage and computation, but values are subject to rounding error.

Type	Storage Required	Signed Range	Unsigned Range
FLOAT	4 bytes	-3.402823466E+38 to -1.175494351E-38	0 and 1.175494351E-38 to 3.402823466E+38
DOUBLE	8 bytes	-1.7976931348623157E+308 to -2.2250738585072014E-308	0 and 2.2250738585072014E-308 to 1.7976931348623157E+308

Fixed-Point Types

The fixed-point data type is DECIMAL . It is used to represent exact-v alue numbers that have an integer part, a fractional part, or both. DECIMAL uses a fixed-decimal storage format: All values in a DECIMAL column have the same number of decimal places and are stored exactly as given when possible. DECIMAL values are not processed quite as efficiently as FLOAT or DOUBLE values (which use the processor's native binary format), but DECIMAL values are not subject to rounding error, so they are more accurate. In other words, there is an accur acy versus speed tradeoff in choosing which type to use. For example, the DECIMAL data type is a popular choice for financial applications involving currency calculations, because accuracy is most important. The amount of storage required for DECIMAL column values depends on the precision and scale. Approximately four bytes are required per nine digits on each side of the decimal point. The maximum range is the same as for DOUBLE; the effective range for a given DECIMAL column is determined by precision and scale.

NUMERIC Data Type

The NUMERIC data type in MySQL is a synonym for DECIMAL. (If a column is declared as NUMERIC,MySQL uses DECIMAL in the definition.) Standard SQL allows for a difference between the two types, but in MySQL they are the same. In standard SQL, the precision for NUMERIC must be exactly the number of digits given in the column definition. The precision for DECIMAL must be at least that many digits but is allowed to be more. In MySQL, the precision is exactly as given, for both types

BIT Types

The BIT data type represents bit-field values. BIT column specifications take a width indicating the number of bits per value, from 1 to 64 bits. For a BIT(n) column, the range of values is 0 to 2 n – 1, and the storage requirement is approximately INT((n +7)/8) bytes per value. BIT columns can also be assigned values using numeric expressions. To write literal bit values in binary format, the literal-value notation b' val' can be used, where val indicates a value consisting of the binary digits 0 and 1. For example, b'1111' equals 15 and b'1000000' equals 64. Rule of thumb for storage size: n=8 takes 1 Byte.

MySQL Data Types

2012-02-09T22:32:00.000-08:00

Before going to deep into the creation of tables, it is important to understand the data types that can be used within MySQL. These data types will be assigned to the columns that will make up the MySQL tables and will need to be understood, not only for ensuring the proper data is being stored but also to ensure a database that performs well. One of the biggest problems associated with database performance is poor design, especially in the choice of data type s that are used in the columns. In MySQL the data types available can be broken down into three major categories:

Numeric • Numeric values (Integers, Floating-Point, Fixed-Point and Bit-field)

String • Text or binary data

Temporal • Time and dates

Within each category there are numerous specific data types that use varying amounts of memory and disk space, thus having varying effects on performance. Choosing the best data type for the column has a rather small effect on performance in an individual record, but as the database grows these small effects can lead to larger effects. This should be taken into accoun t early in the design process, before they become performance issues.

Storage Engines

2012-02-07T10:15:00.000-08:00

When creating a table in MySQL, the storage engine that will be used has to be chosen. If one is not chosen, MySQL uses the default storage engine chosen in the configuration of the server. MySQL supports several storage engines that act as handlers for different table types. MySQL storage engines include both those that handle transaction-safe tables and those that handle non-transaction-safe tables. There are numerous storage engines that MySQL supports; however the most common storage types that are used with PHP are listed below:

• MyISAM -

This storage engine is supported in all MySQL configurations and is the default storage engine for all new tables created (when a specific storage engine is not assigned) in the majority of default installations. This storage engine manages non-transactional tables. It provides high-speed storage and retrieval, as well as fulltext searching capabilities. MyISAM is a disk based storage engine. Aiming for very low overhead, it does not support transactions.

• InnoDB -

InnoDB is also disk based, but offers versioned, fully ACID transactional capabilities. InnoDB requires more disk space than MyISAM to store its data, and this increased overhead is compensated by more aggressive use of memory caching, in order to attain high speeds. InnoDB is included by default in all MySQL 5.0 binary distributions.

• Memory (formerly called "Heap") -

This storage engine provides in-memory (utilizes only RAM) tables. Special algorithms are used that make optimal use of this environment. It is very fast. Like MyISAM, the Memory storage engine handles non-transactional tables, and is also included in MySQL by default.

• NDB -

This is the MySQL Cluster Storage engine which connects to a cluster of nodes, offering high availability through redundancy, high performance through fragmentation (partitioning) of data across multiple node groups, and excellent scalability through the combination of these two. Prior to MySQL 5.1, NDB used main-memory only, with logging to disk.

Table Limits

The MySQL server has no limits overall on the number of tables that can be created in a database; however, there are limits within the storage engine type itself or on in the operating system that contains the MySQL server. InnoDB, for example, limits the number of tables that can be created for the entire database to 2 million tables. This means that one database server can not contain more the 2 million tables across one database or multiple databases. This is because all InnoDB tables are stored in a central files in the operating system and not separated out by database. MyISAM tables on the other hand do not have any such limitations; however, the operating system can oppose limits on the number of files that can be stored on disk or in an individual sub-directory.

MANAGING DATABASE TABLES

2012-02-07T10:08:00.000-08:00

Table Properties

The heart of any database is the tables, because the tables contain the data that is used to provide information to the end users. Tables are contained in databases, and in MySQL each database has an associated "data directory" to store all the physical components of the database, to include tables. This physical representation on disk of the tables is dependent on the type of storage engine that the table is utilizing; however, every table, no matter of the type of storage engine that is being used, contains a format file (table_name.frm) which describes the table definition and structure.

In addition to the physical representation of the table, there is also the better known logical aspect of the table. This logical aspect is represented in rows and columns. Rows within a table, consist of a collection of values that describe an entity (ex. an employee). Columns within a table, consist of a collection of similar data among rows (ex. employee surnames). The intersection of row and column contains individual data items called values. Values are always atomic, in that each position in a table may contain only one datum (piece of data).

Drop a Database

2012-02-07T10:01:00.000-08:00

When a database is no longer needed, it can be removed with DROP DATABASE:

DROP DATABASE my_db;

It is an error if the database does not exist. To cause a warning instead, include an IF EXISTS clause;

DROP DATABASE IF EXISTS my_db;

Any warning generated when IF EXISTS is used can be displayed with SHOW WARNINGS.

DROP DATABASE does not require the database to be empty. When dropping the database, MySQL removes any objects that it contains; such as tables, stored procedures, triggers, etc.

A successful DROP DATABASE returns a row count that indicates the number of tables dropped. (This actually is the number of .frm files removed, which amounts to the same thing.) Use the SHOW DATABASES command to verify that the database has been dropped.

CAUTION: When Using DROP DATABASE

A database is represented by a directory under the data directory. The server deletes only files and directories that it can identify as having been created by itself (for example, .frm files or RAID directories). It does not delete other files and directories. If a non-table files have been placed in that directory, those files are not deleted by the DROP DATABASE command. This results in failure to remove the database directory and DROP DATABASE fails. In that case, the database will continue to be listed by SHOW DATABASES. To correct this problem, manually remove the database directory and any files within it.

Using the Database

2012-02-07T09:54:00.000-08:00

Creating a database has no effect on which database currently is selected as the default database. To make the new database the default database, issue a USE statement:

USE my_db;

After a database has been created, it can be populated with objects such as tables or stored routines. The CREATE statement for tables is discussed in a later chapter.

Displaying Database Structure

The easiest way to display the database structure (as far as the database container) is to issue a SHOW CREATE DATABASE command. This command shows the CREATE DATABASE statement that was used to create the database (or could be used to recreate the database structure):

mysql> SHOW CREATE DATABASE my_db\G
************************* 1. row *************************
Database: my_db
Create Database: CREATE DATABASE `my_db`
/*!40100 DEFAULT CHARACTER SET utf8 COLLATE utf8_danish_ci */

Note: SCHEMA can be interchanged with DATABASE to perform the above statements. (i.e., CREATE SCHEMA mydb;)

Problems

When a CREATE DATABASE command fails, the two most common problems are insufficient or incorrect permissions, or an attempt to create a database that already exists.

Creating Databases

2012-02-07T09:50:00.000-08:00

To create a new database, use the CREATE DATABASE statement. The following statement creates a
database named my_db:

CREATE DATABASE my_db;

If an attempt is made to create a database that already exists, an error occurs. To ensure that the database
exists, add an IF NOT EXISTS clause to the statement:

CREATE DATABASE IF NOT EXISTS my_db;

With the additional clause, the statement creates the database only if it does not already exist. Otherwise, the statement does nothing and no error occurs. This can be useful in applications that need to ensure that a given database is available, without disrupting any existing database with the same name.

The CREATE DATABASE statement has two optional clauses, CHARACTER SET and COLLATE, that assign a default character set and collation for the database. If given, they appear at the end of the statement following the database name. The following statement specifies that the mydb database has a default character set of utf8 and collation of utf8_danish_ci:

CREATE DATABASE my_db CHARACTER SET utf8 COLLATE utf8_danish_ci;

The default character set and collation for the database are used as the defaults for tables created in the database for which no explicit character set or collation of their own are specified. The database defaults are stored in the db.opt file in the database directory. Note: CHARACTER SET is really a column setting. By giving the table or the database a character set, it just affects the columns upon creation.

MySQL Identifiers

2012-02-07T09:08:00.000-08:00

The are five kinds of identifiers that need to be considered in MySQL: databases, tables, columns, indexes and aliases. Databases, as stated are the containers for the tables and other associated database components. Tables hold the data that is used to produce information. Columns are the individual entities of the tables that contain the smallest portion of the data. Indexes in databases refer to the data structures that improve the speed of operations in a table. Aliases are temporary names assigned to database components. The identifiers that can be assigned to each component have their limitations:

• Size -
The following table describes the max length each database identifier can be assigned:

Identifier	Maximum Length
Database	64 Bytes
Table	64 Bytes
Column	64 Bytes
Index	64 Bytes
Alias	255 Bytes

The length of the identifier is in bytes, not characters. The maximum length will depend on the byte count of all the characters used and should be taken into consideration if using multi-byte characters in the identifier names.

Case Sensitivity -

In MySQL, databases correspond to directories within the data directory. Each table within a database corresponds to at least one file within the database directory (and possibly more, depending on the storage engine). Consequently, the case sensitivity of the underlying operating system determines the case sensitivity of database and table names. This means
database and table names are case sensitive in most varieties of Unix, and not case sensitive in Windows.

Although database and table names are not case sensitive on some platforms, database or table names should not be referred to using different cases within the same statement. The following statement would not work because it refers to a table both as my_table and as

MY_TABLE:

mysql> SELECT * FROM my_table WHERE MY_TABLE.col=1;

Character Restrictions -

It is best practice to include only alphanumeric characters (and underscore or dashes) in the identifier names; however, other characters can be used if no other way is acceptable. Here is a list or restrictions that also need to be considered in such an event:

○ No identifier can contain ASCII 0 (0x00) or a byte with a value of 255

○ The use of identifier quote characters in identifiers is permitted, although it is best to avoid
doing so if possible

○ Database, table, and column names should not end with space characters

○ Before MySQL 5.1.6, database names and table names cannot contain “/”, “\”, “.”, or characters that are not allowed in a directory name

○ Identifiers may begin with a digit but unless quoted may not consist solely of digits

○ It is recommended that names of the form Me or MeN, where M and N are integers. For
example, avoid using 1e or 2e2 as identifiers, because an expression such as 1e+3 is
ambiguous. Depending on context, it might be interpreted as the expression 1e + 3 or as the
number 1e+3.

Database Design Practices

2012-02-07T08:51:00.000-08:00

In database discussions, it is common to hear the term normalization or database design come up. However,for the most parts these discussions revolve around splitting up the data that is stored between different tables to improve performance and to eliminate duplication. This is extremely important and should be discussed in any discussion on tables but for the most part the discussions do not involve splitting up data between databases. This is either assumed or just not put into practice as often as it should be. Either way, it is important to consider when designing an application that will need to access data.

Information Commonality Data could be defined as the actual values that are stored in the database itself and are static until they are changed by some process (either manually or automated). Data by itself is useless if not processed in such a way as to give it meaning. Information, on the other hand, is data processed in such a way as to give it meaning and is constantly changing based on the data stored. In addition, the majority of data collected can be processed in multiple ways to provide multiple meaningful outputs. In databases, many developers look at the data that is contained versus the information that the data is designed to provide. Databases should be developed in such a way that each database produces a common set of information. Tables that would hold data associated with human resource information should not be contained in the same database as tables that would contain parts for aircrafts in an airline database system. If there is a need for the data in the inventory database to interact with data in the human resource database to provide the proper information, the MySQL server can pull data from the tables holding the data (even though they are in two different databases) to provide such information.

Exclusive Data

In such situations where there are separate entities that utilize the same data structures, separating out the data may be the safest and most reliable way to ensure data integrity. An example would be an accounting firm that is responsible for the payroll of two or three companies. The application that would be created to support such as system could utilize the same data structures but have separate databases containing the actual data for each company. This would eliminate any chance that data from one company could interact

with data from another company which would create an insecure and potentially precarious situation. This would require time and energy put into ensuring that the database and its underlying components were solid enough to avoid the need for structural changes after implentation. Copying database structures from one database to another is an easy process in MySQL; however, any future changes would have to be done in the individual databases separately.

HOW TO MANAGING DATABASES

2012-02-06T20:46:00.000-08:00

Database Properties

The heart of any database is the tables, because the tables contain the data that is used to provide information to the end users. Tables are contained in databases, and in MySQL each database has an associated "data directory" to store all the physical components of the database, to include tables. This physical representation on disk of the tables is dependent on the type of storage engine that the table is utilizing; however, every table, no matter of the type of storage engine that is being used, contains a format file (table_name.frm) which describes the table definition and structure. In addition to the physical representation of the table, there is also the better known logical aspect of the table. This logical aspect is represented in rows and columns. Rows within a table, consist of a collection of values that describe an entity (ex. an employee). Columns within a table, consist of a collection of similar data among rows (ex. employee surnames). The intersection of row and column contains individual data items called values. Values are always atomic, in that each position in a table may contain only one datum

(piece of data). Without the ability to obtain information from the database, there is no need for the data to be stored.

However, the tables are of little value unless they are contained in a unified and associated manner that allow for the storage, retrieval and manipulation of the data. This is where the database comes in. For its part, the database can be thought of as the container for the tables (which are the containers for the data). In MySQL, databases manage their associated components in locations called "data directories". These data directories (meaning there can be more than one database that the MySQL server can manage) are located in a central sub-directory of the mysql installation and can be seen through the operating system on which the

MySQL Server is running. MySQL "data directories" have the following common structures:

• Data Directory - In MySQL, there is a parent directory for all the databases that are managed by that instance of the MySQL Server.

• Database Name - The database name given to the represent the database in the MySQL server is also the name of the associated data sub-directory. This limits the naming conventions that can be used when giving databases a name.

• Database Components - The data directory is responsible for managing the majority of
component associated with the associated database in the MySQL server. This includes such
components as the tables, stored procedures, triggers, views, etc.

• Database Character Set Support - Each database is defined with a default character set and
collation (a character set is a set of symbols and encodings and a collation is a set of rules for
comparing characters in a character set). This behavior ensures that each table created within the database takes on the same characteristics associated with the default values; however, tables themselves can also be created with different character sets and collations than their database container.

• Database Hierarchy - Databases are "flat" in the sense that they can not be nested, meaning a database can not contain a database itself.

• Unlimited Databases - The MySQL server has no limit on the number of databases that it can
contain; however, the operating system may limit the number of sub-directories that a directory
can contain thus limiting the number of databases that can be created.

Storage Engine Breakdown

2012-02-06T20:45:00.001-08:00

The following diagram represents a simplified view of the MySQL server and its interaction with the storage engines.

The following properties are storage engine dependant:

• Storage Medium – Each table uses its own method of storing the data it contains.

• Transactional Capabilities – Certain storage engines handle transactional processing which
ensures that integrity of a database is maintained during the processing of multiple SQL
statements.

• Locking – Each storage engines handles the processes of the synchronization mechanism for enforcing limits on access to a resource in an environment where there are many threads of
execution.

• Backup and Recovery – Based on the storage medium used, the backup of the table data and the recovery of that data can be distinct.

• Optimization – There are specific issues associated with each storage engine for the optimization of the storage of the data and retrieval of the data through the MySQL server.

• Special Features – There are a number of features that exist only in certain engine types to
include full-text search, referential integrity and the ability to handle spatial data. Most of the MySQL server operates in the same way no matter what storage engine is used: all the usual
SQL commands are independent of the storage engine. Naturally, the optimizer may need to make different choices depending on the storage engine, but this is all handled through a standardized interface (API) which each storage engine supports.

MySQL Query Browser

2012-02-06T20:45:00.000-08:00

MySQL Query Browser is a cross-platform GUI client program that's intuitive and easy to use. It provides
a graphical interface to the MySQL server for querying and analyzing data. The MySQL Query Browser
provides a Connection dialog that enables a connection to a MySQL server. This section describes how to
use the Connection dialog and the Main Query Browser GUI.

Using the Connection Dialog

MySQL Query Browser presents a Connection dialog when it starts or when the New Instance Connection
… is selected from the File menu. Connecting to a MySQL server can be accomplished either by filling in
the connection dialog box fields with the parameters required to connect to a server or selecting from
among any predefined connection profiles.

Connection Dialog Window:

To connect to a MySQL server by specifying connection parameters directly, fill in the appropriate fields beginning with the Username field and click the OK button. To connect using the parameters stored in a connection profile, select the profile from the Connection drop-down list and click the OK button.

The MySQL Query Browser Window

The main MySQL Query Browser window is divided up into several sections:

o Query Toolbar - The query toolbar is where queries can be created and executed. It is composed of three navigation buttons (Go Back, Next, Refresh), the query area, two action
buttons (Execute and Stop), and a status indicator.

o Advanced Toolbar - The advanced toolbar contains three sets of buttons: the Transaction Buttons (Start, Commit, Rollback), the query management buttons (Explain, Compare), and the query building buttons (Select, From, Where, and so on.)
• The Advanced Toolbar is only visible when the Show advanced toolbars and Show composer
buttons toolbar options in the Browser Options screen are checked.

o Results Area - All query results are displayed in the result area. Multiple tabs can be active at one time, allowing multiple queries to be worked on. The result area can be split vertically and
horizontally for performing comparisons, and queries in different parts of a split result area can be joined together for master-detail analysis.

o Object Browser - The object browser is part of the sidebar and allows for the management of the databases, bookmarks, and history. Databases and tables can be chosen to query, in addition to the ability to add commonly-used queries to a collection of bookmarks, and browse through previously issued queries in order to use them again.

If there are many schemata on your MySQL server, the search field with the magnifying glass icon may be handy for filtering the schemata. Typing in t or T, for example, will set the filter to schemata whose names begin with a t. The filter works in a case-insensitive fashion.

Filter schemata can also use the wild card (?) to stand in for any single character and (*) for zero to any number of characters. For example the string *boo?* will find schemata with the names books, coursebooks, and bookings.

o Information Browser - The Information Browser is part of the sidebar and is used to look up built-in functions, and to manage queries that contain parameters. One example of this is when establishing a master-detail pair of queries. The data in the master query is available as parameters to the detail query. Using the View menu, most of these sections can be displayed and hidden by checking and unchecking the elements.

The mysql Client

2012-02-01T00:55:00.000-08:00

The mysql Client

This section discusses mysql, a general-purpose client program for issuing queries and retrieving their
results. It can be used interactively or in batch mode to read queries from a file.

Using mysql Interactively

The mysql client program enables the sending of queries to the MySQL server with any results being
displayed in the same interface. It can be used interactively or it can read query input from a file in batch
mode:

• Interactive mode is useful for day-to-day usage, for quick one-time queries, and for testing how
queries work.

• Batch mode is useful for running queries that have been prewritten and stored in a file. It's especially valuable for issuing a complex series of queries that's difficult to enter manually, or queries that need to be run automatically by a job scheduler without user intervention. MySQL statements such as the version query, shown below as executed within the mysql client, can also be run from the shell command prompt as part of the mysql client startup;

mysql> SELECT VERSION();

+-----------------+
| VERSION() |
+-----------------+
| 5.0.41-log |
+-----------------+

You can execute a statement directly from the command line by using the -e or --execute option:

shell> mysql -u user_name -ppassword -e "SELECT VERSION()"

+-----------------+
| VERSION() |
+-----------------+
| 5.0.41-log |
+-----------------+

No statement terminator is necessary unless the string following -e consists of multiple statements. In that case, separate the statements by semicolon characters.

Statement Terminators

There are numerous terminators that can be used in the mysql client to end a statement. Two terminators
are the semicolon character (';') and the \g sequence. They're equivalent and may be used
interchangeably:

mysql> SELECT VERSION(), DATABASE();

+-----------------+--------------------+
| VERSION() | DATABASE() |
+-----------------+--------------------+
| 5.0.40-log | INFORMATION_SCHEMA |
+-----------------+--------------------+

The \G sequence also terminates queries, but causes mysql to display query results in a vertical style that
shows each output row with each column value on a separate line:

mysql> SELECT VERSION(), DATABASE()\G

************************** 1. row **************************

VERSION(): 5.0.40-log
DATABASE(): INFORMATION_SCHEMA

The \G terminator is especially useful if a query produces very wide output lines because vertical format
can make the result much easier to read.

The mysql client allows a single query to be entered using multiple input lines. This makes it easier to
issue a long query because you can enter it over the course of several lines. mysql will wait until it sees
the statement terminator before sending the query to the server to be executed. For example:

mysql> SELECT TABLE_SCHEMA, TABLE_NAME, TABLE_TYPE
-> FROM INFORMATION_SCHEMA.TABLES
-> WHERE TABLE_NAME LIKE 'E%';
+--------------------+-----------------+-----------------+
| TABLE_SCHEMA | TABLE_NAME | TABLE_TYPE |
+--------------------+-----------------+------------------+
| information_schema | ENGINES | SYSTEM VIEW |
| information_schema | EVENTS | SYSTEM VIEW |
| mysql | event | BASE TABLE |
+--------------------+-----------------+------------------+
3 rows in set (#.## sec)

In the preceding example, mysql changes the prompt from mysql> to -> to provide feedback that it's still waiting to see the end of the statement.

If a statement results in an error, mysql displays the following error message:

mysql> This is an invalid statement;
ERROR 1064 (42000): You have an error in your SQL syntax.

If it is necessary to cancel a statement once mysql has already received some of the input, enter \c and

mysql will cancel the statement and return the mysql> prompt:

mysql> SELECT * FROM INFORMATION_SCHEMA > WHERE \c
mysql>

To quit mysql, use \q, QUIT, or EXIT: mysql> \q

SQL Parser and Storage Engine Tier

2012-01-31T23:24:00.000-08:00

A client retrieves data from tables or changes data in tables by sending requests to the server in the form of SQL statements. The server executes each statement using a two-tier processing model:

• The upper tier includes the SQL parser and optimizer.

• The lower tier comprises a set of storage engines.

For the most part, the SQL tier is free of dependencies on which the storage engine manages any given table. This means that clients normally need not be concerned about which engines are involved in processing SQL statements, and can access and manipulate tables using statements that are the same no matter which engine manages them. Exceptions to this engine-independence of SQL statements include the following:

• CREATE TABLE has an ENGINE option that enables you to specify which storage engine to use on a per-table basis. ALTER TABLE has an ENGINE option that enables you to convert a table to use a different storage engine.

• Some index types are available only for particular storage engines. For example, only the MyISAM engine supports full-text or spatial indexes.

• COMMIT and ROLLBACK have an effect only for tables managed by transactional storage engines such as InnoDB.

MySQL General Architecture

2012-01-31T23:19:00.000-08:00

MySQL operates in a networked environment using a client/server architecture. In other words, a central program acts as a server, and various client programs connect to the server to make requests. A MySQL installation has the following major components: MySQL Server, Client programs and MySQL non client utilities.

MySQL Server

MySQL Server, or mysqld, is the database server program. The server manages access to the actual database (schema) on disk and in memory. MySQL Server is multi-threaded and supports many simultaneous client connections. Clients can connect via several connection protocols. For managing database contents, the MySQL server features a modular architecture that supports multiple storage engines that handle different types of tables (for example, it supports both transactional and non-transactional tables).

Keep in mind the difference between a server and a host. The server is software (the MySQL server program mysqld). Server characteristics include its version number, whether certain features are included or excluded, and so forth. The host is the physical machine on which the server program runs. Host characteristics include its hardware configuration, the operating system running on the machine, its network addresses, and so forth.

Client Programs

These are programs that are used for communicating with the server to manipulate the databases that are managed by the server. MySQL AB provides several client programs. The following list describes a few of them:

MySQL Query Browser and MySQL Administrator are graphical interfaces to the server.

mysql is a command-line program that acts as a text-based front end for the server. It's used for issuing queries and viewing the results interactively from a terminal window.

Other command-line clients include mysql import for importing data files, mysqldump for making backups, mysql admin for server administration, and mysqlcheck for checking the integrity of the database files.

MySQL Client/Server Model

MySQL runs on many varieties of Windows, Unix, and Linux, but client/server communication is not limited to environments where all computers run the same operating system. Client programs can connect to a server running on the same host or a different host, and the client and server host need not have the same operating system. For example, client programs can be used on Windows to connect to a server that is running on Linux. Most of the concepts discussed here apply universally to any system on which MySQL runs. Platformspecific

information is so indicated. Unless otherwise specified, “Unix” as used here includes Linux and

other Unix-like operating systems.

MYSQL FOUNDATIONS

2012-01-31T21:44:00.000-08:00

MySQL server

What is the MySQL Server?

MySQL is a relational database that can be used to store dynamic Web page data for services such as online catalogs and stores, create accounting databases, and create address books. MySQL is an advanced feature for users that are familiar with databases and SQL (structured query language). For more information, go to http://www.mysql.com.

If the MySQL server is enabled, users on the internal network can access personal databases and the databases of any teams to which they belong. User and team databases are automatically created when user and team accounts are set up.

Setting up Windows for MySQL Access

You can use Microsoft^(R) Access to access and manage database tables.
1. You first have to download the MySQL ODBC (Open Database Connectivity)
connector. You can download this at http://dev.mysql.com/downloads/connector/.

2. On the page that is displayed, click the link for the Connector/ODBC. Ensure you are downloading the most recent stable release.

3. From the Windows downloads section of the screen that displays, click the download link for Windows or Windows x64.

4. On the screen that is displayed, select the nearest server to download from.

5. In the window that is displayed, select the download location where you want to save the mysql-connector-odbc file. This set of steps assumes that it is saved to the desktop.

6. Double-click the icon on your desktop and click Run.

7. The Microsoft ODBC Setup screen is displayed. Click Continue.

8. Select MySQL from the Available ODBC Drivers list. Click OK.

9. For Windows XP and later, click Start -> Settings -> Control Panel -> Administrative
Tools -> Data Sources (ODBC). For previous versions of Windows, click Start -> Settings -> Control Panel -> ODBC Data Source. The ODBC Data Source Administrator screen is displayed.

10. Click Add.... The Create New Data Source screen is displayed.

11. Select MySQL from the list. Click Finish.

12. Provide the following information:

a Windows DSN Name (such as MySQL Address Book)
your Lotus Foundations server's host name or IP address
your MySQL database name, user name, and password.

13. Click OK on this screen and then on the ODBC Data Source Administrator screen.

14. Open Microsoft Access.

15. Create a database named address book.

16. Anywhere in this window, right-click your mouse. Select Link Tables.

17. In the Files of Type section of the screen that is displayed, select ODBC Databases.

The Select Data Source screen is displayed.

18. Select the Machine Data Source tab and select MySQL Address Book. The Link Tables screen is displayed.

19. Select the appropriate table, then click OK.

20. Make sure that the appropriate table is highlighted and click OK. The table opens in Microsoft Access.

PHP User Defined Functions

2012-01-28T07:14:00.000-08:00

PHP is packed full with many useful built-in functions, such as print() and mysql_query(), which meet a variety of needs. However, there will be times when a non-standard function would best meet the needs of the application that is being built. This is where user defined functions come in handy. The programmer can of course write the same piece of code over and over again in their applications to produce the result or they can create a user defined function that can be reused over and over again. This is the primary advantage of custom functions. The actual code associated with built-in functions consists of the keyword function followed by the function name. Next comes the parentheses, which may contain variable names, and the actual function code itself, enclosed in curly braces:

function function_name () {
-- Statements that make up the function code
}

The following examples demonstrate some of the uses and capabilities for creating a user defined function:

<?php
function hello ($i) {
echo "Hello $i!";
}
hello('world'); // This would print "Hello world!"
?>

<?php
function ctable ($i='Test', $b=1, $p=1, $s=1) {
print "<table border=$b, cellpadding=$p cellspacing=$s>";
print "<tr><td>$i</td></tr></table>";
}
ctable(); /* Would create a HTML table with the word Test in
the cell and with the default table structures */
ctable('Hello World!', 2, 3, 3); /* The defaults would be
overwritten with the
values entered */
?>

The first example displays a typical function that has a value that is entered ($i) and then used within the function itself. The second example displays how a programmer can assign a default value to be associated with the values to be read. This is eliminates any problems with a function called not having all the required values necessary to execute properly. In addition, to having information sent into a function, it is also possible to have a value returned:

<?php
function circumference ($diameter) {
$c = $diameter * pi();
return(printf("%01.2f",$c));
}
circumference(3); // This would return 9.4
?>

PHP Break and Continue

2012-01-27T01:09:00.000-08:00

With iterative control statements, PHP provides two means of manually interrupting the flow of the loops.These two commands include break (which has already been used in examples up to this point) and continue. The following example demonstrates how these two loop interrupts can be used in iterative

control statements:

<?php
for ($test=1; $test < 10; $test = $test + 1) {
if ($test==3) continue;
if ($test==6) break;
echo "The test number is $test<br>";
}
?>

The following output would be displayed when this PHP script was run:

The test number is 1
The test number is 2
The test number is 4
The test number is 5

When the $test variable was equal to 3, the script skipped the remain code and performed the next iteration of the for function. This resulted in the number 3 not being printed. In addition, when the $test variable was equal to 6, the break function ended the for function thus resulting in the remainder of the script being missed resulting in the number 6 not being printed.

PHP FOR STATEMENT

2012-01-26T10:10:00.000-08:00

FOR

The for function is the more complex sibling of the while function and provides a more streamline and complex looping mechanism. The for function takes three expressions; the first expression is evaluated by default at the first iteration of the loop, the second expression is evaluated at the beginning of each iteration (and determines if the loop will continue) and the third expression is evaluated at the conclusion of each loop. Any of the expressions can be empty and the logic that would take place in the expression can be substituted in the body of the function itself. The statement list within the for code body can consist of one or more statements.

for (expression1; expression2; expression3)
{
-- statements that execute while the expressions evaluates false
}

The following examples demonstrate how the for iterative control statement can work:

<?php
for ($ctemp = 0; $ctemp <= 20; $ctemp = $ctemp + 1) {
$ftemp = 32 + $ctemp / 5 * 9;
echo "$ctemp -> $ftemp<br>";
}
?>
<?php
for ($ctemp = 0; ; $ctemp = $ctemp + 1) {
$ftemp = 32 + $ctemp / 5 * 9;
echo "$ctemp -> $ftemp<br>";
if ($ctemp >= 20) break;
}
?>
<?php
$ctemp = 0;
for (;;) {
$ftemp = 32 + $ctemp / 5 * 9;
echo "$ctemp -> $ftemp<br>";
if ($ctemp >= 20) break;
$ctemp = $ctemp + 1;
}
?>

FOREACH

The foreach function is the iterative control statement that is designed specifically for handling arrays (and objects as of PHP 5). There are two ways of using the foreach iterative control statement. The first ways is by looping over the array given by the array_expression and assigning the current array element to the $value variable.

foreach (array_expression as $value) {
-- statements that execute until the array reaches the end or a
manual break is inserted
}

The second way of using the foreach function is similar to the first, except the element value is assigned to a $key variable.

foreach (array_expression as $key => $value) {
-- statements that execute until the array reaches the end or a
manual break is inserted
}

Each time the foreach command is initiated, the internal pointer to the array is reset and each iteration advances the pointer one element. The following examples demonstrate how the foreach iterative control statement can work:

<?php
$last_name = array("Smith", "Jones", "Sanchez", "Green");
foreach ($last_name as $individual) {
print "Last Name = $individual<br>";
}
?>

<?php
$wk_temp = array(
'Sunday' => 13,
'Monday' => 12,
'Tuesday' => 11,
'Wednesday' => 13,
'Thursday' => 15,
'Friday' => 17,
'Saturday' => 9);
$wk_avg = 0;
foreach($wk_temp as $day => $temp) {
echo "$day = $temp<br>";
$wk_avg = $wk_avg + $temp;
}
$wk_avg = $wk_avg / 7;
echo "The average temperature for the week was $wk_avg";
?>

PHP Control Flow (while)

2012-01-20T01:26:00.000-08:00

While

The while function is the simplest of all the iterative control statements. The statement list within a while statement is repeated as long as the condition evaluated has not been met. The statement list within the while code body can consist of one or more statements.

while (expression)

{
-- statements that execute while the expression evaluates false
}

It is a best practice to build error detecting logic into any iterative control statement. This error control logic should be built in such a way as to detect an infinite loop. In the following example, simple logic has been built into a while function to detect an infinite loop error:

<?php
    $i = 5;
    while ($i < 5) {
        echo '$i <br>';
        $i = $i++;
        if ($i > 20000) { // Break when > 20,000 repititions
            break;
        }
    }
?>

Do ... While

     The do ... while function is based on the while iterative control statement with the difference being the condition is evaluated at the end of the statement execution versus at the beginning. The statement list within a do ... while function is repeated as long as the condition evaluated has not been met. The statement list within the do ... while code body can consist of one or more statements.

do {
    -- statements that execute while the expression evaluates false
       and then it iterates through the statements one more time
} while (expression);

A do ... while statement will always be guaranteed to run through the statements contained at least once. The following example demonstrates how a do ... while statement works:

<?php
    $i = 10;
    do {
        echo $i * $i;
        $i = $i+;
    } while ($i < 5);

/* The number 100 will be displayed, even though 10 is not less than
5. If this was a while statement, the statements would not have run
at all */
?>

PHP Data Types

2012-01-13T05:55:00.000-08:00

A data type identifies the characteristics that the assigned data will be interpreted by when interacting with the PHP programming language. When a value is assigned a specific data type, the PHP interpreter will work with the data based on the expected type of data it is. For example, 27654 could be considered a numeric data type or it could be considered a string data type, such as in the zip code for a customer. Even though you could perform mathematical equations on the zip code, it would make no sense to do so. Thus,zip codes, even though they look like they would be numeric numbers should be identified as a string data type to eliminate problems such as zip codes that start with zero (ex. 08102). Assigning the correct data type to the expected value is an important part of working with PHP. There are three categories of data types in PHP: Scalar, Compound and Special.

PHP supports eight primitive types.

Four scalar types:

boolean
integer
float (floating-point number, aka double)
string

Two compound types:

array
object

And finally two special types:

resource
NULL

<?php

$a_bool = TRUE;   // a boolean$a_str  = "foo";  // a string$a_str2 = 'foo';  // a string$an_int = 12;     // an integerecho gettype($a_bool); // prints out:  booleanecho gettype($a_str);  // prints out:  string

// If this is an integer, increment it by fourif (is_int($an_int)) {
    $an_int += 4;
}// If $a_bool is a string, print it out
// (does not print out anything)if (is_string($a_bool)) {
    echo "String: $a_bool";
}?>

Scalar types

Booleans

This is the simplest type. A boolean expresses a truth value. It can be either TRUE or FALSE.

Syntax

To specify a boolean literal, use the keywords TRUE or FALSE. Both are case-insensitive.

<?php
$foo = True; // assign the value TRUE to $foo?>

Integers

An integer is a number of the set ℤ = {..., -2, -1, 0, 1, 2, ...}.

Syntax

Integers can be specified in decimal (base 10), hexadecimal (base 16), octal (base 8) or binary (base 2) notation, optionally preceded by a sign (- or +).

Binary integer literals are available since PHP 5.4.0.

To use octal notation, precede the number with a 0 (zero). To use hexadecimal notation precede the number with 0x. To use binary notation precede the number with 0b.

<?php
$a = 1234; // decimal number$a = -123; // a negative number$a = 0123; // octal number (equivalent to 83 decimal)$a = 0x1A; // hexadecimal number (equivalent to 26 decimal)?>

The maximum number that can be assigned to an integer is based on the system. 32 bit systems have a maximum signed integer range of -2147483648 to 2147483647. The maximum signed integer value for 64 bit systems is 9223372036854775807.Any value that exceeds the maximum integer size will be assigned the float data type

Float

Floating point numbers (also known as "floats", "doubles", or "real numbers") can be specified using any of the following syntaxes:

<?php
$a = 1.234; $b = 1.2e3; $c = 7E-10;?>

The size of a floating point number is dependent by the system being used. In addition, floating point numbers are not as accurate as integer numbers when it comes to precision. Even simple numbers like 0.2 and 0.17 can not be converted into their binary equivalents without a loss of precision. With that said, floating point numbers should never be used in comparison operations

without building in logic such as rounding numbers prior to the comparison operation or using a tolerance value that would be an acceptable difference between the compared values for comparison operations.

Strings

A string data type is a series of characters that are associated with each other in a defined order. There is no limit to the length of a string data value. The following represent some of the values that can be assigned to a string data type:

<?phpecho 'this is a simple string';

echo 'You can also have embedded newlines in
strings this way as it is
okay to do';// Outputs: Arnold once said: "I'll be back"echo 'Arnold once said: "I\'ll be back"';// Outputs: You deleted C:\*.*?echo 'You deleted C:\\*.*?';// Outputs: You deleted C:\*.*?echo 'You deleted C:\*.*?';// Outputs: This will not expand: \n a newlineecho 'This will not expand: \n a newline';// Outputs: Variables do not $expand $eitherecho 'Variables do not $expand $either';?>

The characters that can be used in PHP string data types are limited to the ISO 8859-1 or Latin-1 character set. This character set allows for 256 (the size of a byte) different possible characters (191 of them that are actually printable); however, there is support in PHP to encode strings to the UTF-8 standard (UTF-8 is a standard mechanism used by Unicode for encoding wide character values into a byte stream).

Compound types:

A compound data type allows for multiple values to be associated with a single entity. The primary purpose of a compound data type is to act as containers for other kinds of data. In PHP, there are two types of data types that fall under into this category.

Arrays

An array in PHP is actually an ordered map. A map is a type that associates values to keys. This type is optimized for several different uses; it can be treated as an array, list (vector), hash table (an implementation of a map), dictionary, collection, stack, queue, and probably more. As array values can be other arrays, trees and multidimensional arrays are also possible.

Explanation of those data structures is beyond the scope of this manual, but at least one example is provided for each of them. For more information, look towards the considerable literature that exists about this broad topic.

<?php

$Country[0] = "Australia"; // Australia is the first(0) value

$Country[1] = "Russia"; // Russia is the second(1) value

$Country[2] = "Germany"; // Germany is the third(2) value

$Country[3] = "France"; // France is the fourth(3) value

// The following will display: Let's go to Germany!

print "Let's go to $Country[2]!";

?>

The above example could be written less explicitly:

<?php

$Country = array("Australia", "Russia", "Germany", "France");

print "Let's go to $Country[2]!";

?>

Rather than using numeric identifiers, array identifiers can be more meaningful when created as in

the following examples:

<?php

$Capital["Australia"] = "Canberra";

$Capital["Russia"] = "Moscow";

$Capital["Germany"] = "Berlin";

$Capital["France"] = "Paris";

print "The capital of Russia is ".$Capital["Russia"]."!";

?>

<?php

$Capital = array(

"Australia" => "Canberra",

"Russia" => "Moscow",

"Germany" => "Berlin",

"France" => "Paris");

print "The capital of Russia is ".$Capital["Russia"]."!";

?>

Objects

The data type referred to as an object is the key to the object-oriented programming paradigm. The object, can be thought of as a "black box" in which information is sent into it, processed and a result is sent out. The developer has no need to know anything about the internal workings of the code thus giving power to the idea of creating and using objects of already-existing code. Up to this point in the discussion of data types, there has been no need to explicitly declare a data type. PHP determines the data type based on the value that is being stored. However, objects must be explicitly declared. This declaration, which includes the object's characteristics and behavior, takes place within a class. The following is an example of an object declaration:

<?php

class respect {

private $name;

function setRespect($name) {

$this->name = 'Mr./Ms. '.$name;

print $this->name;

}

$boss = new respect;

$boss->setRespect("Jane Riker");

In this simple object example, the result of all this coding is a proper title being placed in front of the boss' name. However, this object could be reused over and over again throughout the remained of the application:

<?php

$assistant = new respect;

$assistant->setRespect("Wes Picard");

Special types:

Resources

A resource is a special variable, holding a reference to an external resource. Resources are created and used by special functions. See the appendix for a listing of all these functions and the corresponding resource types.

Converting to resource

As resource variables hold special handlers to opened files, database connections, image canvas areas and the like, converting to a resource makes no sense.

Freeing resources

Thanks to the reference-counting system introduced with PHP 4's Zend Engine, a resource with no more references to it is detected automatically, and it is freed by the garbage collector. For this reason, it is rarely necessary to free the memory manually.

One of the benefits of using PHP is its ability to interact with some external data

source: databases, files, network streams, etc. To utilize these external data sources, PHP must create handles that are named when a successful connection is initiated. These handles continue to be the main point of reference for any communication that takes place. When the communication process is completed, the handle is destroyed and the connection is terminated. These handles fall under the resource data type.

<?php

$dbLink = mysql_connect ("localhost","root","training") or

die("Could not connect to MySQL server");

$query = "SHOW TABLES FROM INFORMATION SCHEMA";

$result = mysql_query($query);

While ($row = mysql_fetch_array($result)) {

print row[0]."<br>";

}

mysql_close();

In the example above, the $dbLink variable is assigned a resource data type based on the action that is taking place (connecting to the local MySQL database server). If $dbLink was referenced directly, a reference to a resource id would be returned

NULL

The special NULL value represents a variable with no value. NULL is the only possible value of type NULL.

A variable is considered to be null if:

it has been assigned the constant NULL.
it has not been set to any value yet.
it has been unset().

<?php
$SSAN = '112-34-5677';
unset($SSAN);
?>

Syntax

There is only one value of type null, and that is the case-insensitive keyword NULL.

<?php

$var = NULL; ?>

Different Types of Output Methods in PHP

2012-01-12T05:21:00.000-08:00

The strength of the web has been the ability for practically anyone to provide information (accurate or not) to anyone who is interested in viewing the web pages that contain that information. With HTML, the static nature of the information being displayed limits the amount of true customization that can be provided; however, PHP provides truly dynamic content by creating custom content each time the web page is displayed. To accomplish this display of information, PHP has four functions that make this happen:

• print() -

This statement is designed to provide user feedback; in other words, this function "prints" content to the HTML code which in turn will be displayed on the web page when called. The print() function can display both raw strings and variables.

<?php
print('<p>This is the standard use of the print function.</p>');
print '<p>However, the parentheses are not necessary.</p>';
$var = "print";
print "<p>Variables can also be included with the $var
function.</p>";
print '<p>Another way to add a variable to a ' . $var .
' function is to concatenate it to the strings</p>';
?>

As shown above, there are multiple ways to use the print function. In addition, breaking the function components across multiple lines is acceptable. The function will continue to read the components until it reaches the semi-colon delimiter (;) which tells the function to complete the process.

• echo -

The echo function is similar to the print function in that it can "print" content to the HTML code; however, it can not be used in more complex expressions because it returns a void versus the print function which will return a boolean value. Except for this difference, the echo function is no different than the print function. With that thought in mind, many programmers choose to just use the print function to prevent this limitation as they advance in their programming skills.

<?php
echo '<p>This is the standard use of the echo function.</p>';
$var = 'echo';
echo "<p>The $functionType function can also use embedded
variables.</p>";
echo '<p>However, when concatenating with the ', $functionType,
' function, it is best to use commas to concatenate the
strings</p>';
?>

• printf() -

The printf function performs the same function as the print command with the exception that there is greater control over the formatting of the "printed" text. The printf function works from the standard print approach for "printing" text to HTML:

<?php

printf('<p>This is the standard use of the printf function</p>');

Of course, the above demonstration does not add any value to the standard print function. But the printf function does not stop there, the following demonstrations show how the format argument can be included to provide a level of formatting to the strings referenced in the printf function:

<?php

printf('<p>%d Euro = $%01.2f US Dollar</p>', 1, 1.3);

printf('<p>My %s paid $%01.2f for my $s</p>', 'Mother', 23.4,

"Dog");

printf('<p>However, my %3\$s paid $%2\$01.2f to get away from my

%1\$s</p>', 'Mother', 100.3, 'Dog');

printf('<p>%11s</p>', 'Long text can be limited to a certain

number of characters, in this case 11.');

A complete list of supported type specifiers is located in Appendix D. In the case of the third printf function listed above, the location of the string argument can be chosen by placing the location (#$) with the format type. In the case of %3\$s, the third argument was selected and formatted as a string. The reason for the escape character (\) preceding the dollar sign ($) is to ensure that it was considered part of the formatting versus an actual dollar sign as used in the first printf function.

• sprintf() -

The sprintf function performs the same functions as the printf function except it stores the result of the function into a variable.

<?php

$orderTotal = sprintf('$%01.2f', 123.456);

print "The order total is $orderTotal";

PHP Control Flow (if...elseif....else)

2012-01-11T06:11:00.000-08:00

PHP starts with many strengths in its logical and bitwise operators. PHP then extends the ideas of C, Java and Perl control of flow and looping functionality - giving them more of the ease of use associated with Visual Basic or Ruby. Also enhancing the functionality of its associative array, PHP has some powerful control commands with list(), each() and foreach().

Finally, PHP takes full advantage of its mixed type capability for variables and functions. Thus functions like fopen() return a value (a file handle in the case of fopen() finding a file for opening) or the Boolean false if no file was found. Developers have to be alert to these different

Very often when you write code, you want to perform different actions for different decisions.

You can use conditional statements in your code to do this.

In PHP we have the following conditional statements:

if statement - use this statement to execute some code only if a specified condition is true
if...else statement - use this statement to execute some code if a condition is true and another code if the condition is false
if...elseif....else statement - use this statement to select one of several blocks of code to be executed
switch statement - use this statement to select one of many blocks of code to be executed

Conditional Operators

PHP allows you to perform a number of different comparisons, to check for the equality or relative size of two values. PHP’s conditional operators are shown in Table 3.1.

Table 3.1 Conditional Operators in PHP

Operator	Description
`==`	Is equal to
`===`	Is identical to (is equal and is the same data type)
`!=`	Is not equal to
`!==`	Is not identical to
`<`	Is less than
`<=`	Is less than or equal to
`>`	Is greater than
`>=`	Is greater than or equal to

Logical Operators

You can combine multiple expressions to check two or more criteria in a single conditional statement. For example, the following statement checks whether the value of $number is between 5 and 10:

$number = 8;
if ($number >= 5 and $number <= 10) {
 echo "$number is between five and ten";
}

The keyword and is a logical operator, which signifies that the overall condition will be true only if the expressions on either side are true. That is, $number has to be both greater than or equal to 5 and less than or equal to 10.

Table 3.2 shows the logical operators that can be used in PHP.

Table 3.2 Logical Operators in PHP

Operator	Name	Description
`!` a	NOT	True if a is not true
a `&&` b	AND	True if both a and b are true
a `\|\|` b	OR	True if either a or b is true
a `and` b	AND	True if both a and b are true
a `xor` b	XOR	True if a or b is true, but not both
`a or b`	OR	True if either a or b is true

You may have noticed that there are two different ways of performing a logical AND or OR in PHP. The difference between and and && (and between or and ||) is the precedence used to evaluate expressions.

Table 3.2 lists the highest-precedence operators first. The following conditions, which appear to do the same thing, are subtly but significantly different:

a or b and c
a || b and c

In the former condition, the and takes precedence and is evaluated first. The overall condition is true if a is true or if both b and c are true.

In the latter condition, the || takes precedence, so c must be true, as must either a or b, to satisfy the condition.

if Conditions

Simple if statement

Syntax

if (conditions)
 Do this;

In the above code, the Do this; statement will either run or not run depending on whether or not the conditions are true. This syntax can only be used when the condition affects a single line of code. For a block of code, use the following syntax.

Syntax

if (conditions)
{
 Do this;
 Then do this;
 And this too;
}

The lines of code affected by the if condition are put in a code block, which is surrounded by curly brackets to indicate that all of the code either should or should not be executed, depending on the result of the if condition.

if-else statement

Syntax

if (conditions)
{
 Do this;
}
else
{
 Do that;
}

if-elseif-else statement

Syntax

if (conditions)
{
 Do this;
}
elseif (other conditions)
{
 Do that;
}
else
{
 Do this other thing;
}

The two syntax blocks above show an if-else and an if-elseif-else statement, which can have any number ofelseif blocks.

EXAMPLE

<?php

$currentDate = time();

if (strtotime($_POST['DateEntered']) > $currentDate) {

echo 'That date is in the future';

} elseif (strtotime($_POST['DateEntered']) < $currentDate) {

echo 'That date is in the past';

} else {

echo 'That is today';

}

<?php

$currentDate = time();

if (strtotime($_POST['DateEntered']) > $currentDate)

{

echo 'That date is in the future';

}

else if (strtotime($_POST['DateEntered']) < $currentDate)

{

echo 'That date is in the past';

}

else

{

echo 'That is today';

}

Comments

2012-01-10T21:55:00.000-08:00

When it comes to commenting code, the consensus is it is necessary but the reality is it rarely is done. It has been said that commenting code is like cleaning the bathroom - no one ever wants to do it but a clean bathroom creates a more pleasant experience for all that will need to use it. There are many types of commenting strategies with each having advantages and disadvantages over each other. The key is to comment, how that is accomplished is best worked within a team environment and calls for a great deal of flexibility. The following are types of typical commenting that should be considered along with how they would be implemented inside of PHP code:

Code Commenting

This form of commenting is not considered traditional commenting (in the sense of creating remarks to support the code) but is closer related to good programming design principles. This best practice approach

to coding involves using coding names that describe the action that is taking place.

<?php 
 echo "hello"; 
 //this is a comment 
 echo " there"; 
 ?>

These examples show that the variable or function name give a description of what is being performed. Before abbreviating any code identifiers, make sure that they are descriptive enough so that others who would need to read the code would understand their meaning upon first glance. Any time that needs to be devoted to deciphering a given naming convention is clearly a waste of time and should be considered over any advantage of minimizing the extra key strokes required by the initial programmers.

InLine Commenting

The most basic form of commenting is that which is referred to as inline or single line commenting. This
type of commenting has its history in C++ and has become the standard approach to commenting for many
programmers (when they comment). PHP supports this type of commenting by using two consecutive
forward slashes (//) preceding any comments added.

<html>

<body>

<?php

//This is a comment

This is

a comment

block

</body>

</html>

With inline comments, there is no need to delimit the comments conclusion, the carriage return (\n) performs that action.

Delimiting PHP Code

2012-01-10T06:49:00.000-08:00

PHP was originally designed to be used in conjunction with a web server, and in the case of the LAMP
architecture, the Apache Web Server. PHP applications are designed embedding PHP scripts within a web
page along with its HTML. Unlike standard HTML pages which are sent directly from the web server to
the end user, PHP files are first interpreted by the PHP application which then converts the PHP script into
another form for display. This process eliminates the end user from being able to see the original PHP
script that was embedded in the HTML and provides true interaction in HTML files. This process is
similar to proprietary applications such as ASP and Coldfusion; however, PHP is Open Source and cross-
platform.

PHP Tags

PHP scripts are distinguished from the HTML scripts by using delimiting characters that tell the server to
execute the PHP application to interpret that which is contained in the code. There are four ways to
accomplish this; however, the first two listed below are the safest for portability and conflict prevention:

• Default Syntax - The default syntax is starting the PHP script with <?php and closing out the script
with ?>. The following example demonstrates how this would look within HTML code:

<html><head><title>PHP Default Syntax</title></head>
<body>
<h3>PHP Default Syntax</h3>
<?php
print "This is an example of using PHP Default Syntax";
?>
</body></html>

• Script Syntax - Due to limitations with certain HTML editors, PHP added the ability to support a
mainstream delimiter variant, <script>. The following example demonstrates how this would
look:

<script language="php">
print "This is an example of using PHP script delimiting
syntax";
</script>

• Short Tags - Due to the fact that many programmers are interested in minimizing the amount of code
that needs to be written to accomplish a task, PHP implemented a shorter delimiter syntax to support
this desire. Instead of needing to type <?php to start the PHP script, programmers can simply type
<? to start the PHP script. The following example demonstrates how this would look:

<?
print "This is an example of using PHP Short Tag Syntax";
?>

• ASP-Style - There are many PHP programmers that have experience with other similar programming
languages, such as ASP. ASP delimits code using <% and %>. PHP has provided support for this
type of delimiting. The following example demonstrates how this would look:

<%
print "This is an example of using ASP-Style delimiting syntax";
%>

PHP INTRODUCTION

2012-01-09T10:07:00.000-08:00

PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML.

PHP stands for PHP: Hypertext Preprocessor
PHP is a server-side scripting language, like ASP
PHP scripts are executed on the server
PHP supports many databases (MySQL, Informix, Oracle, Sybase, Solid, PostgreSQL, Generic ODBC, etc.)
PHP is an open source software
PHP is free to download and use

Why PHP?

PHP runs on different platforms (Windows, Linux, Unix, etc.)
PHP is compatible with almost all servers used today (Apache, IIS, etc.)
PHP is FREE to download from the official PHP resource: www.php.net
PHP is easy to learn and runs efficiently on the server side

What can PHP do?

Anything. PHP is mainly focused on server-side scripting, so you can do anything any other CGI program can do, such as collect form data, generate dynamic page content, or send and receive cookies. But PHP can do much more.

There are three main areas where PHP scripts are used.

Server-side scripting. This is the most traditional and main target field for PHP. You need three things to make this work. The PHP parser (CGI or server module), a web server and a web browser. You need to run the web server, with a connected PHP installation. You can access the PHP program output with a web browser, viewing the PHP page through the server. All these can run on your home machine if you are just experimenting with PHP programming. See the installation instructions section for more information.
Command line scripting. You can make a PHP script to run it without any server or browser. You only need the PHP parser to use it this way. This type of usage is ideal for scripts regularly executed using cron (on *nix or Linux) or Task Scheduler (on Windows). These scripts can also be used for simple text processing tasks. See the section about Command line usage of PHP for more information.
Writing desktop applications. PHP is probably not the very best language to create a desktop application with a graphical user interface, but if you know PHP very well, and would like to use some advanced PHP features in your client-side applications you can also use PHP-GTK to write such programs. You also have the ability to write cross-platform applications this way. PHP-GTK is an extension to PHP, not available in the main distribution.

PHP can be used on all major operating systems, including Linux, many Unix variants (including HP-UX, Solaris and OpenBSD), Microsoft Windows, Mac OS X, RISC OS, and probably others. PHP has also support for most of the web servers today. This includes Apache, IIS, and many others. And this includes any web server that can utilize the FastCGI PHP binary, like lighttpd and nginx. PHP works as either a module, or as a CGI processor.

So with PHP, you have the freedom of choosing an operating system and a web server. Furthermore, you also have the choice of using procedural programming or object oriented programming (OOP), or a mixture of them both.

With PHP you are not limited to output HTML. PHP's abilities includes outputting images, PDF files and even Flash movies (using libswf and Ming) generated on the fly. You can also output easily any text, such as XHTML and any other XML file. PHP can autogenerate these files, and save them in the file system, instead of printing it out, forming a server-side cache for your dynamic content.

One of the strongest and most significant features in PHP is its support for a wide range of databases. Writing a database-enabled web page is incredibly simple using one of the database specific extensions (e.g., for mysql), or using an abstraction layer like PDO, or connect to any database supporting the Open Database Connection standard via the ODBC extension. Other databases may utilize cURL or sockets, like CouchDB.

PHP also has support for talking to other services using protocols such as LDAP, IMAP, SNMP, NNTP, POP3, HTTP, COM (on Windows) and countless others. You can also open raw network sockets and interact using any other protocol. PHP has support for the WDDX complex data exchange between virtually all Web programming languages. Talking about interconnection, PHP has support for instantiation of Java objects and using them transparently as PHP objects.

PHP has useful text processing features, which includes the Perl compatible regular expressions (PCRE), and many extensions and tools to parse and access XML documents. PHP standardizes all of the XML extensions on the solid base of libxml2, and extends the feature set adding SimpleXML, XMLReader and XMLWriter support.

And many other interesting extensions exist, which are categorized both alphabetically and by category. And there are additional PECL extensions that may or may not be documented within the PHP manual itself

As you can see this page is not enough to list all the features and benefits PHP can offer. Read on in the sections about installing PHP, and see the function reference part for explanation of the extensions mentioned here.

ABOUT WAMP

2012-01-08T06:53:00.000-08:00

WAMPs are packages of independently-created programs installed on computers that use a Microsoft Windows operating system.

WAMP is an acronym formed from the initials of the operating system Microsoft Windows and the principal components of the package:Apache, MySQL and one of PHP. Apache is a web server. MySQL is an open-source database. PHP is a scripting language that can manipulate information held in a database and generate web pages dynamically each time content is requested by a browser. Other programs may also be included in a package, such as phpMyAdmin which provides a graphical user interface for the MySQL database manager, or the alternative scripting languages Python or Perl. Equivalent packages are MAMP (for the Apple Mac) and LAMP (for the Linuxoperating system).

To download WAMP click here

MySQL INTRODUCTON

2012-01-07T10:04:00.000-08:00

So after learning HTML lets go into the working part
lets first see what is MySQL and then go to php

MySQL is installed on every continent in the world (Yes, even Antarctica!) MySQL AB MySQL is a relational Database Management System (RDBMS). MySQL AB develops and markets a family of high performance, affordable database servers and tools. Contributing to building the mission-critical,high-volume systems and products worldwide is what makes MySQL the world’s most popular open source database, as well as its reliability, excellent performance and ease of use. MySQL is not only the world’s most popular open source database, it’s also the fastest growing database in the industry, with more than 11 million active installations and 50,000 downloads per day. The company was founded in Sweden by two Swedes and a Finn: David Axmark, Allan Larsson and Michael "Monty" Widenius who have worked together since the 80's. MySQL AB(Swedish for “Inc.”) is the sole owner of the MySQL server source code, the MySQL trademark and the MySQL .com domain worldwide. MySQL has always been a strong supporter of the Open Source philosophy and the Open Source Community, and strives to work with partners that share the same values and mind-set.

• The MySQL mission: To make superior database software available and affordable to all.

MySQL Products
MySQL provides database products to meet the needs of ISV/OEM, Enterprise, and Community Server users. MySQL database products are recognized for superior ease of use, performance, and reliability.

• Enterprise Server

The most reliable, secure and up-to-date version of the world's most popular open source database for cost-effectively delivering E-commerce, Online Transaction Processing (OLTP), and multi-terabyte Data Warehousing applications. (Available only with the MySQL Enterprise subscription).

• Community Server

The MySQL database server for open source developers and technology enthusiasts who want to get started with MySQL. Supported by the large MySQL open source community. Under the General Public License (GPL), benefits to the open source community include a commercial-grade framework that is free of charge.

• Embedded Database

The most popular choice for OEMs/ISVs who want to cost-effectively embed or bundle a reliable and high-performance relational database.

• Cluster

A fault tolerant database clustering architecture for deploying highly available mission-critical

database applications.

• MaxDB

Formerly known as SAP DB, MaxDB is the result of a strategic alliance between MySQL and

SAP to jointly develop and market an open source database for SAP/R3

MySQL Enterprise

A comprehensive set of enterprise-grade software, support and services directly from the developers of MySQL to ensure the highest levels of reliability, security and uptime. As a proactive service that helps you eliminate problems before they occur, it gives you everything you need in a single, unified offering to

successfully develop and deploy business critical applications using MySQL.

• Enterprise Server

• Network Monitoring and Advisory

Services to ensure the maximum quality, uptime, and performance of MySQL Enterprise systems.

• Production Support

Around-the-clock support for the MySQL Enterprise server, along with consulting services and self-help knowledge aids.

MySQL GUI Tools

A comprehensive set of open source visual database tools. These easy to use visual tools enable database developers and DBAs to be more productive.

• MySQL Migration Toolkit

Using a wizard-driven interface, the MySQL Migration Toolkit implements a proven methodology and walks you through the necessary steps to successfully complete a database migration project.

• MySQL Administrator

A powerful visual administration console that enables you to easily administer your MySQL environment and gain significantly better visibility into how your databases are operating.

• MySQL Query Browser

An extremely user-friendly visual tool for creating, executing, and optimizing SQL queries for your MySQL Database Server.

• SQLyog Community
SQLyog is a GUI tool for the RDBMS MySQL. It is developed by Webyog, Inc. based out of Bangalore, India and Santa Clara, California.

SQLyog is available in free as well as paid versions. The free version is known as Community Edition and is available as an open source project . Paid version are sold as Professional, Enterprise and Ultimate Editions .
To download Community Edition click here

MySQL Drivers

Standards-based drivers (also known as Connectors) enable developers to build database applications in

their language of choice. In addition, a native C library allows developers to embed MySQL directly into their ‘C’ applications. MySQL provides the following drivers:

• MySQL Connector/ODBC

Connect to a MySQL database server using the ODBC database API on all Microsoft Windows and most Unix platforms.

• MySQL Connector/J

A native Java driver that converts JDBC (Java Database Connectivity) calls into the network protocol used by the MySQL database.

• MySQL Connector/Net

An ADO.NET provider that allows access from the .NET platform using the network protocol used by the MySQL database.

• MySQL Connector/MXJ

An MBean that allows seamlessly embedding the MySQL database server within the J2EE environment.

• MySQL Connector/PHP (New to the MySQL family of Connectors)

For connecting to MYSQL from PHP on Windows (not necessary for Unix variants).

To download Drivers click here

HTML Tags

2012-01-04T11:30:00.000-08:00

HTML Tags

What are HTML tags?

HTML tags are used to mark-up HTML elements
HTML tags are surrounded by the two characters < and >
The surrounding characters are called angle brackets
HTML tags normally come in pairs like <b> and </b>
The first tag in a pair is the start tag, the second tag is the end tag
The text between the start and end tags is the element content
HTML tags are not case sensitive, <b> means the same as <B>

Logical vs. Physical Tags

In HTML there are both logical tags and physical tags. Logical tags are designed to describe (to the

browser) the enclosed text's meaning. An example of a logical tag is the <strong> </strong> tag. By

placing text in between these tags you are telling the browser that the text has some greater

importance. By default all browsers make the text appear bold when in between the <strong> and

</strong> tags.

Physical tags on the other hand provide specific instructions on how to display the text they enclose.
Examples of physical tags include:

<b>: Makes the text bold.
<big>: Makes the text usually one size bigger than what's around it.
<i>: Makes text italic.

Physical tags were invented to add style to HTML pages because style sheets were not around, though

the original intention of HTML was to not have physical tags. Rather than use physical tags to style

your HTML pages, you should use style sheets.

HTML Elements
Remember the HTML example from the previous page:

<html>
<head>
<title>My First Webpage</title>
</head>
<body>
This is my first homepage. <b>This text is bold</b>
</body>
</html>

This is an HTML element:

<b>This text is bold</b>

The HTML element begins with a start tag: <b>
The content of the HTML element is: This text is bold
The HTML element ends with an end tag: </b>

The purpose of the <b> tag is to define an HTML element that should be displayed as bold.

This is also an HTML element:

<body>
This is my first homepage. <b>This text is bold</b>
</body>

This HTML element starts with the start tag <body>, and ends with the end tag </body>. The purpose
of the <body> tag is to define the HTML element that contains the body of the HTML document.

Nested Tags

You may have noticed in the example above, the <body> tag also contains other tags, like the <b> tab.
When you enclose an element in with multiple tags, the last tag opened should be the first tag closed.
For example:

<p><b><em>This is NOT the proper way to close nested tags.</p></em></b>

<p><b><em>This is the proper way to close nested tags. </em></b></p>

Why Use Lowercase Tags?
You may notice we've used lowercase tags even though I said that HTML tags are not case sensitive.
<B> means the same as <b>. The World Wide Web Consortium (W3C), the group responsible for
developing web standards, recommends lowercase tags in their HTML 4 recommendation, and XHTML
(the next generation HTML) requires lowercase tags.

Tag Attributes
Tags can have attributes. Attributes can provide additional information about the HTML elements on
your page. The <tag> tells the browser to do something, while the attribute tells the browser how to
do it. For instance, if we add the bgcolor attribute, we can tell the browser that the background color
of your page should be blue, like this: <body bgcolor="blue">.

This tag defines an HTML table: <table>. With an added border attribute, you can tell the browser that
the table should have no borders: <table border="0">. Attributes always come in name/value pairs
like this: name="value". Attributes are always added to the start tag of an HTML element and the
value is surrounded by quotes.

Quote Styles, "red" or 'red'?
Attribute values should always be enclosed in quotes. Double style quotes are the most common, but
single style quotes are also allowed. In some rare situations, like when the attribute value itself
contains quotes, it is necessary to use single quotes:

name='George "machine Gun" Kelly'
For a complete list of tags, visit W3C.org.

Basic HTML Tags

The most important tags in HTML are tags that define headings, paragraphs and line breaks.

Basic HTML Tags

Tag	Description
<html>	Defines an HTML document
<body>	Defines the document's body
<h1> to <h6>	Defines header 1 to header 6
<p>	Defines a paragraph
<br>	Inserts a single line break
<hr>	Defines a horizontal rule
<!-->	Defines a comment

Headings
Headings are defined with the <h1> to <h6> tags. <h1> defines the largest heading while <h6> defines
the smallest.
<h1>This is a heading</h1>
<h2>This is a heading</h2>
<h3>This is a heading</h3>
<h4>This is a heading</h4>

<h5>This is a heading</h5>
<h6> This is a heading</h6>

HTML automatically adds an extra blank line before and after a headin g. A useful heading attribute is
align.

<h5 align="left">I can align headings </h5>

<h5 align="center">This is a centered heading </h5>

<h5 align="right" >This is a heading aligned to the right </h5>

Paragraphs

Paragraphs are defined with the <p> tag. Think of a paragraph as a bl ock of text. You can use the align
attribute with a paragraph tag as well.

<p align="left">This is a paragraph</p>

<p align="center">this is another paragraph</p>

Important: You must indicate paragraphs with <p> elements. A browser ignores any
indentations or blank lines in the source text. Without <p> elements, the document becomes
one large paragraph. HTML automatically adds an extra blank line before and after a paragraph.

Line Breaks

The <br> tag is used when you want to start a new line, but don't want to start a new paragraph. The
<br> tag forces a line break wherever you place it. It is similar to single spacing in a document.

This Code Would Display
<p>This <br> is a para<br> graph with
line breaks</p>
This
is a para
graph with line breaks

The <br> tag has no closing tag.

Horizontal Rule
The <hr> element is used for horizontal rules that act as dividers between sections, like this:

The horizontal rule does not have a closing tag. It takes attributes such as align and width. For
instance:

This Code Would Display
<hr width="50%" align="center">

Comments in HTML

The comment tag is used to insert a comment in the HTML source code. A comment can be placed
anywhere in the document and the browser will ignore everything inside the brackets. You can use
comments to write notes to yourself, or write a helpful message to someone looking at your source
code.

Notice you don't see the text between the tags  . If you look at the source code, you
would see the comment. To view the source code for this page, in your browser window, select View
and then select Source .

Note: You need an exclamation po int after the opening bracket  .

HTML automatically adds an extra blank line before and after some elements, like before and after a
paragraph, and before and after a heading. If you wa nt to insert blank lines into your document, use
the <br> tag.

This Code	Would Display
<p> This html comment would <!-- This	This HTML comment would be displayed likethis.

Try It Out!
Open your text editor and type the following text:

<html>
<head>
<title>My First Webpage</title>
</head>
<body>
<h1 align="center">My First Webpage</h1>
<p>Welcome to my first web page. I am writing this page using a text editor and plain
old html.</p>
<p>By learning html, I'll be able to create web pages like a pro....<br>
which I am of course.</p>
</body>
</html>

Save the page as mypage2.html. Open the file in your Internet browser. To view how the page
should look, visit this web page: http://profdevtrain.austincc.edu/html/mypage2.html
for more html details click here

HTML INTRODUCTION

2012-01-03T22:21:00.000-08:00

What is an html File?

HTML is a format that tells a computer how to display a web page. The documents themselves are plain text files with special "tags" or codes that a web browser uses to interpret and display information on your computer screen.

HTML stands for Hyper Text Markup Language
An HTML file is a text file containing small markup tags
The markup tags tell the Web browser how to display the page
An HTML file must have an htm or html file extension

Try It?

Open your text editor and type the following text:

<html>
<head>
<title>My First Webpage</title>
</head>
<body>
This is my first homepage. <b>This text is bold</b>
</body>
</html>

Save the file as mypage.html. Start your Internet browser. Select Open (or Open Page) in the File menu of your browser. A dialog box will appear. Select Browse (or Choose File) and locate the html file you just created - mypage.html - select it and click Open. Now you should see an address in the dialog box, for example C:\MyDocuments\mypage.html. Click OK, and the browser will display the page. To view how the page should look, visit this web page: http://profdevtrain.austincc.edu/html/mypage.html

Example Explained

What you just made is a skeleton html document. This is the minimum required information for a web document and all web documents should contain these basic components. The first tag in your html document is <html>. This tag tells your browser that this is the start of an html document. The last tag in your document is </html>. This tag tells your browser that this is the end of the html document.
The text between the <head> tag and the </head> tag is header information. Header information is not displayed in the browser window.

The text between the <title> tags is the title of your document. The <title> tag is used to uniquely identify each document and is also displayed in the title bar of the browser window.
The text between the <body> tags is the text that will be displayed in your browser.
The text between the <b> and </b> tags will be displayed in a bold font.

HTM or HTML Extension?

When you save an HTML file, you can use either the .htm or the .html extension. The .htm extension comes from the past when some of the commonly used software only allowed three letter extensions. It is perfectly safe to use either .html or .htm, but be consistent. mypage.htm and mypage.html are treated as different files by the browser.

How to View HTML Source

A good way to learn HTML is to look at how other people have coded their html pages. To find out, simply click on the View option in your browsers toolbar and select Source or Page Source. This will open a window that shows you the actual HTML of the page. Go ahead and view the source html for this page.

IF YOU WANT TO KNOW MORE ABOUT HTML CLICK HERE

2012-01-03T22:19:00.000-08:00

SO LETS START... HOW CAN DO THIS? THERE ARE THREE WAYS

1. Use a pre-made template: WHAT IS A WEB DESIGN TEMPLATE?

A web site design template is a pre-made website design template which can be customized to reflect your company’s branding. Website design templates can be found in various formats like Photoshop and HTML. Many times, these templates are compatible with HTML editors like GoLive, FrontPage, and Dreamweaver.
Web site templates can be very useful; they can be used by experienced web designers to ‘jump-start’ the creation of a website. They are also a way for people to put out great-looking web sites quickly with little or no knowledge of HTML and web design.CLICK HERE TO GET FREE TEMPLATES

2. Use an HTML editor like FrontPage or Dreamweaver:

HTML editors make building web pages feel like (to a certain extent) creating a document in Microsoft Word … it’s made pretty easy. But the downside is that you lose a certain amount of control of what you’re doing and in some cases become dependent on the program.

3. Hand-code your HTML in a text editor like Notepad:

That means you type in the HTML code yourself. This is the approach we are going to use here, because it’s the quickest way to learn how to build web pages, and it is arguably the best way because you have the most control over what you’re doing.
Ok, now that we know the advantages of hand-coding web pages, let’s jump into just the bare minimum of theory, then we will build our first web page!

TOOLS NEED FOR BUILDIND A WEB

2012-01-03T01:20:00.000-08:00

Firebug

Firebug is a free, open source in-browser web development tool for the Firefox web browser. It’s many features include: on-the-fly HTML and CSS editing for tweaking or debugging, a Console for logging, analyzing and debugging JavaScript, and an intuitive Document Object Model (DOM) inspection tool to help you quickly see how the elements of a web page relates to one another.
Firebug’s popularity is so immense it’s one of the few Firefox extensions that have its own extensions (like YSlow and FirePHP)!

Dreamweaver

Adobe Dreamweaver is a commercial application for web development that’s available for the Mac and Windows operating systems. Its featured-packed suite of tools and options include: syntax highlighting and very smart Code Hinting, a built-in FTP client, project management and workflow options that make team work effortless, and Live View – which shows you a preview of your source code. Dreamweaver tightly integrates with other popular Adobe products such as Photoshop, allowing you to share Smart Objects for quick and easy updating and editing of graphics components

CSS Grid Builder

CSS Grid Builder is an online GUI for customizing the YUI Grids CSS – a lightweight CSS framework developed by Yahoo! that comes with over 1000 page layout combinations. The CSS Grid Builder allows you to rapidly generate a CSS-based, web-standards compliant page layout in a matter of minutes (or even seconds). Once you’ve got the page layout the way you want it, all you have to do is press "Show Code" and it generates the HTML for you.
You don’t even have to host the CSS file on your web server (saving you some bandwidth and maintenance hassles), the generated code links to the appropriate stylesheet found on Yahoo!’s Developer Network API.

Clean AJAX

Clean AJAX speeds up Ajax development by cutting down the amount of code you have to write (and rewrite), giving you access to common and proven design patterns used in Ajax applications. Clean AJAX can be used with any server-side technology such as PHP, RoR, and .NET because it’s JavaScript-based. Check out the demo page so you can see Clean AJAX in action.

Notable mentions

Here are other tools that were voted on that are worth a quick mention.

Adobe Flash
Web Developer (Firefox extension)
Aptana
paper and pen/pencil (for paper prototyping/sketching).
CSSEdit
Notepad++
GIMP

website introduction

2012-01-03T01:05:00.000-08:00

Get started now – no experience required!

How-to-build-websites.com is designed for total beginners … and for people who use programs like Dreamweaver, FrontPage, and other wysiwyg programs (wysiwyg stands for: “What You See Is What You Get”) … and now want to learn what’s going on ‘behind the scenes’.

What is the web?

In a nutshell, the web is a whole bunch of interconnected computers talking to one another. The computers (on the web) are typically connected by phone lines, digital satellite signals, cables, and other types of data-transfer mechanisms. A ‘data-transfer mechanism’ is a nerd’s way of saying: a way to move information from point A to point B to point C and so on.
The computers that make up the web can be connected all the time (24/7), or they can be connected only periodically. The computers that are connected all the time are typically called a ‘server’. Servers are computers just like the one you’re using now to read this article, with one major difference, they have a special software installed called ‘server’ software.

What is the function of server software / programs?

Server software is created to ‘serve’ web pages and web sites. Basically, the server computer has a bunch of web sites loaded on it and it just waits for people (via web browsers) to request or ask for a particular page. When the browser requests a page the server sends it out.

How does the web surfer find a web site?

The short answer is: by typing in the URL, or in other words, the web site address. So for example, if you wanted to find the web site www.w3school.com, you would type in the address into your web browser’s address bar or maybe use your ‘favorites’ or ‘bookmarks’ link to Killersites.
There are other ways to find web sites (like search engines,) but behind the scenes web sites are all being found by going to the web site’s official address. That brings us our last nerd detail: how does a website get an official address so that the rest of the web can find it?

Registering your domain name

If you ever wondered what the heck registering a domain was all about … you probably figured it out by now! But just in case – registering a domain name gets you an official address for your web site on the World Wide Web. With this ‘official’ address, the rest of the web can find you.
Like your home address is unique in the real world, there also can’t be any duplicate addresses on the Internet, otherwise no one would know where to go! In other words, domain names are unique addresses on the web.

Why does registering a domain name cost money?

If you want to have your own unique address on the web, your own domain name, it will cost a few bucks for each year you want to ‘own’ the name. The cost of registering a domain name ranges from less than $10 USD to about $30 USD per year. You can register a domain from 1 to 10 years.
The reason for the cost is that the central ‘address book’ of all the world’s domain names needs to be updated – somebody’s got to pay for that! You may have noticed that I just snuck in a little extra piece of information: the giant ‘web address book’ of domains.
That leads us to our last bit of nerd information: when you type in a website’s domain name or click on a link that takes you to that domain name, your browser starts asking servers where that particular domain name is sitting (on the web) and the servers are then able to tell the browser where to go by referring to the giant address book I mentioned above.