For small and large database projects, Microsoft Access works wonderfully. If you have a database with hundreds of thousands of records, maybe even connecting to other databases remotely. Security isn’t too much of a problem (no Access database is truly secure), and with a wide range of options for publishing and reporting on your data.

That is, until you try to put it online. That”s where converting your Access database to MySQL comes in.

While Microsoft Access is great as a desktop solution, it weakens greatly when transferred online. The limits on users and speed still exist, and it”s not built to work well on platforms other than Microsoft. Unfortunately for Microsoft Access, most web servers run a form of Unix, not Windows.

Enter MySQL.

MySQL is a relational database system designed specifically for use online and housed on the most common servers online. It”s fast, robust, clean, free, and fairly intuitive to work with as long as you have a very solid understanding of all things SQL. Converting to MySQL from Microsoft Access isn”t without it”s set of problems, however there are a few things you can do to make sure that this conversion goes smoothly.

1. Organize and clean your Microsoft Access database before converting to MySQL! This can”t be stressed enough and it”s pretty much the sole reason your conversion from Access to MySQL will fail or succeed. Think of upgrading from Access to MySQL like a complicated high-wire act. If one person has trouble going across that wire, chances are making him ride a bicycle across it while balancing a ball on his nose will only end up in disaster … and a broken bicycle. Re-design your Microsoft Access database if you have to, but be absolutely sure that your database is designed flawlessly.

2. Set up your MySQL database. Just as making sure your Access database is designed flawlessly, your MySQL database must be designed just as flawlessly. MySQL has different data types than Microsoft Access does – you won”t find memo fields, for instance – so be sure that your existing data will fit into the structure you build for MySQL. Otherwise, all you”re going to get is a mess of mish-mashed data.

3. Export your Microsoft Access data to text files. Fortunately, MySQL has a very handy interface called phpMyAdmin. This allows you to interact directly with your tables through a somewhat graphical UI. All you need to have are tables and fields set up that match your data, and you can click, “Import Data from Text File” through phpMyAdmin. Browse to the text file, import it, and congratulations, your data is online!

While there is certainly more details to be learned regarding the process of converting from Microsoft Access to MySQL, always keep in mind the fundamentals. Databases that are designed perfectly will circumvent 95% of the problems that generally befall poorly designed ones. Converting Access to MySQL isn”t terribly difficult or time consuming, but it can be very tricky. Back up your data, make sure you”ve designed databases properly on both sides, and your data could be up in no time. Then, it”s on to PHP!

Author: David Badurina, President of Blue Moose Technology, LLC, is a relational database design expert specializing in turning hideous data nightmares into efficient, intuitive database applications.

This article explains how to retrieve XML document by using data stored in SQL SERVER.And here iam not doing any hard code, simply by configuring the IIS to support XML to retrieve data from database.

About XML

In the business world, clients share data to carry out business. The data that client share can be stored in different formats. To integrate and exchange the data stored in different data formats, you need to convert the data into one common format for exchange between different applications.

To overcome this, W3C defines XML as the common data format for exchange between different applications. And also XML is CrossPlatform, hardware and software independent. XML is purely Text Based Mark Up Language; here we concentrate on “What the DATA “not “How the DATA�. It enables you to store data in a structured format by using meaningful tags. XML is very similar to database. Unlike database, XML document store data in the form of plain text, which can be used across various platform.

In XML, you can very well specify the structure of the data by creating a Document Type Definition (DTD) or XML schema. When you include DTD in the XML Document, the software checks the structure of the XML Document against the DTD. The process of checking the structure of the XML Document is called validating. And this carry out by PARSER In DTD, we can very well specify the Structure and what comes next and also the data type in DTD.

Sample XML Document

[source:xml]

<? xml version=�1.0�? >
<stores>
<store id=�1001� >
<title>BU1032 </title>
<price>450 </price>
<ord_date>29-062006 </ord_date>
</store>
<store id=�1002� >
<title>AU1032 </title>
< price>550 </price>
< ord_date>13-052006 </ord_date>
</store>
</stores>

[/source]

The above XML Document does not contain any formatting instruction. To change the look and feel of the XML Document, W3C has specified extensible stylesheet language transformation (XSLT). XSLT is the language used to format the XML Document and displaying them in required format. XSLT follows the XML syntax.

Retrieving XML Document By Using Data Stored In SQL SERVER

Most of them are familiar with, How webpage is being hosted in the web server and how the data getting retrieved from the database and how the data getting updated in the database. However, if you want to display the data stored on the database in web page, you need to write the code by using any technology like ASP or ADO. In order to simplify the task of creating web pages that display data from Database, Ms-SQL Server2000 provides integration with XML. SQL Server 2000 allows you to generate XML Document by using data stored in a DB. These document can be used for providing devices-independent data. You can also display the resulting XML Document in the supporting web browser.

Support feature in SQL Server 2000

Sql server is a RDBMS. Therefore all operations on the tables stored in a SQL SERVER DB produce a result in the form of a table. SQL SERVER 2000 has introduced features, such as URL Query and XPath queries, for integrating XML with SQL Server.

* FOR XML clause: The FOR XML clause of the SELECT statement can be used to generate an XML document based on the data returned by a query.

* OPENXML function: It provide the OPENXML function that can be used in a T-SQL statement. This function has the ability to represent an XML document as a rowset.

* Direct URL Queries: The SQL Sever XML Support for IIS utility is used to process direct URL queries. This utility parses the query and sends it to SQL server, which generate the result as an XML document.

* XPath Queries: An XPath Query is an XML-based query language that can be used to process the data in XML documents. The XML Support for IIS utility of SQL Server 2000 can be used to process XPath queries and generate the result as an XML Document.

Generating an XML Document

SQL Server 2000 provides the SQL-XML mapping rules for extracting the XML data from DB. You can use FOR XML clause of the select statement to extract data from the DB and display it as an XML Document.

In FOR XML Clause, data are retrieved in 3 different modes such as AUTO, RAW, and EXPLICIT.

Syntax for FOR XML

[source:sql]

SELECT *
FROM table_name
FOR XML mode_type

[/source]

AUTO MODE: The AUTO mode returns the query result as nested XML element.

RAW MODE: The RAW mode takes the query result and transforms each row in the result set into an XML element with a generic row identifier as the element tag. This mode maps the columns that have non-null values to an attribute of an XML element.

EXPLICIT: If you specify the EXPLICIT mode, you must ensure that the generated XML document is well-formed and valid. An EXPLICIT mode query produces a universal table that contains all the information about resultant XML tree.

As I stated earlier, you can use the SELECT statement with the FOR XML clause to generate an XML document from the db. If you want to display the resulting XML document in a browser, you need to compose the URL according to the requirement.

Syntax of a URL query: http:///?sql=&root=root_element_name

To use this URL in the browser, you need to create the web site on a web server. A web server can be implemented by installing IIS in any windows OS. After that you need to create the virtual directory and that virtual directory map to physical directory.

SQLSERVER also allows you to create the a virtual directory on a web site by using the Configure SQL XML Support in IIS option in the SQL SERVER program group.

Steps to create Virtual Directory:

1. Create a folder called stores (depends on you) under the c:\inetpub\wwroot directory.
2. Select the Configure SQL XML Support in IIS option from Microsoft SQL SERVER program group. This will open the IIS virtual directory management. Right click the default web page site node in the tree displayed. Select New->Virtual Directory->this will invoke the new virtual directory properties window.
Click the general tab. Type the name of the new virtual dir as stores. Set the physical path of the virtual directory  to c:\inetpub\wwroot\stores
3. Then select the security tab, specify the User Name and Password to be used to connect the sql server.
4. Then select the data source tab, and specify the Database name and server name to be associated with the virtual dir.
5. Click the Setting tab. Check the Allow URL Queries and Allow XPath check boxes to enable a user to send URL and Xpath queries from the browser.
6. Click Ok and close the IIS Virtual Directory Management.

Execution Part: http://localhost/stores?sql=SELECT+*+FROM+sales+FOR+XML+AUTO&root=sales

Copyright @  Sathiyasivam 2007

Microsoft Message Queuing (MSMQ) technology enables applications running at different times to communicate across different networks and even the systems that may be available. MSMQ component delivery the message without file, efficient routing, security, reliable, and priority-based messaging. Even MSMQ handles both asynchronous and synchronous messaging type queuing.

Due to the high-speed networks, new requirement for technology to cater to a lot of high scale distributed applications. Now a day’s everything has to be fast and reliable even if the applications are not in the same location. To resolve this Microsoft introduced 3-Tier Arch. Even there is some many draw back in the 3-tier Arch, Consider a situation when so many people trying to register for a course in the university. Due to the over load server can’t able to response to the huge request. Because of that huge request, so many users request are rejected. To avoid this Microsoft Introduced MSMQ. MSMQ allows the application running at different times to communicate across different network and even the systems that may be available. It supports reliable transaction.
It enables the application to communicate across different network; even the server is temporally not available. Client Applications send and stores the messages to queues and read messages from queues.

What is a message?
A message is a collection data or chunk of information that is sent from a process running on client pc to other running process on the same or different computers on different network.

Queue?
Queues are nothing but First-In-First-Out (FIFO) data structures. Queues can be created using the MSMQ management tool through code or manually. Queues can be created and used dynamically. However you need to be aware of issues that might be caused by replication delays in the case of public queues. Private queues does not have such issues And there is no limitation for queues in MSMQ. You can able to create ‘n’ number of queues.

Types of Queues:

• Public queues are those that are published in the MQIS and are replicated throughout the Enterprise. They can hence be located by any computer on the Enterprise.
• Private queues on the other hand are not published in the MQIS and can only be accessed by systems that have access to the full path name or format name of the queue.

• Store and Forward Communication
  It enables applications to send requests to other applications even the destination is unreachable at the same time. It queued (store) the application and process the request once the destination is reachable.
• Concurrent Execution
  It allows sending request to heterogeneous network without getting acknowledged from the destination. We can also compare it with parallel process.

• Guaranteed Message Delivery
• Asynchronous communication
• Transaction support
• Message routing services
• High scalability
• Integration with Windows NT Security System

Where do we need?

MSMQ features

Sample Demo Application
This sample application to support people to register for application. And this application provide User interface using ASP.NET. Once the User completed entering the message and the message called the MessageQueue, which in turn call the “registration “ which is a private queue in my local system. A server Application implementing MSMQ provides the Message Processing by adding this information to a database and sending a response email.

Client Code to store MSMQ Message:

[source:c#]

try
{
System.Messaging.MessageQueue mq = new System.Messaging.MessageQueue (path.Text);

mq.DefaultPropertiesToSend.Recoverable=true;
mq.DefaultPropertiesToSend.Label=”registration”;
//Test myTest = new Test(txtuserid.Text,txtpass.Text,txtcpass.Text,txtname.Text,txtcname.Text,txtadd.Text,txtcity.Text,txtcon.Text,txtemail.Text);
Test myTest = new Test(txtuserid.Text,txtpass.Text,txtcpass.Text,txtname.Text,txtcname.Text,txtadd.Text,txtcity.Text,txtcon.Text,txtemail.Text,phone.Text);
System.Messaging.Message msg=new System.Messaging.Message();
msg.Formatter =new System.Messaging.BinaryMessageFormatter();
msg.Body=myTest;
//txtadd.Text=”123″;
mq.Send(msg,”registration”,System.Messaging.MessageQueueTransactionType.Single);

// Code to send email
string strTo = txtemail.Text;
string strFrom = “Your _mail@rediffmail.com”;
string strSubject = “Thank you “+txtname.Text+” for testing my demo application”;
string message=”Dear “+txtname.Text+”,”+”\n\n”+”Thank you for testing my demo application. I hope you understand the scope of MSMQ.”+”\n\n”+”Thanks\n”+”S.SathiyaSivam”;
SmtpMail.SmtpServer = “localhost”;
System.Web.Mail.SmtpMail.SmtpServer = “localhost”;
SmtpMail.Send(strFrom, strTo, strSubject,
message);

}

[/source]

Code to retrieve from message from queue:

[source:c#]

MessageQueue q  = new MessageQueue(@”.\Private$\registration”);
Test tst=null;
if(MessageId!=null)
{
// need to strip off the curly brackets to use ReceiveById!
string msgid=((string)MessageId).Replace(“}”,”");
msgid=msgid.Replace(“{“,”");
msg= q.ReceiveById(msgid);
Type[] expectedTypes= new Type[]{typeof(string)};
msg.Formatter =new System.Messaging.BinaryMessageFormatter();
System.Diagnostics.Debug.WriteLine(msg.Id.ToString());
tst=(Test)msg.Body;
}

MessageBox.Show(“Your Request Is Processed From The Queue”);
string sSql=”Insert into registration (UserId,Pass,Cpass,Name,Cname,Padd,city,Country,Email,Phone)Values(‘”+tst.Uid+”‘,’”+tst.Pass+”‘,’”+tst.Cpass +”‘,’”+tst.Uname+”‘,’”+tst.Cname+”‘,’”+tst.Add+”‘,’”+tst.City+”‘,’”+tst.Con+”‘,’”+tst.Email+”‘,’”+tst.Phone+”‘)”;
System.Diagnostics.Debug.WriteLine(sSql);
SqlConnection cn =new SqlConnection(“Server=.;Database=TEST;Trusted_Connection=True;”);
cn.Open();
SqlCommand cmd=new SqlCommand(sSql,cn);
cmd.CommandType=CommandType.Text;
cmd.ExecuteNonQuery();
cmd.Dispose();
cn.Close();

[/source]
Steps to create private queue :

1. Create a new Private Queue called “registrtion”
2. Check the Transactional Queue check box in the Private Queue window.
3. Create a new Trigger for Peeking, enabled, serialized, called “Registration”
4. Create a new Rule called “reg_rule” with a Rule Condition of “Message Label contains registration”
5. For the Rule Action, specify the path to the backend project executable (on my machine, this is “C:\CSHARPBIN\registration\backend\bin\Debug\backend.exe”
6. In Parameters, pass the MessageId as Variant, and the MessageBody as String.
7. In your Trigger’s attached rules, ensure that the Rule Notify is attached.
8. Ensure that both the MessageQueue and the MessageQueue Trigger services are running.

Copyright @ Sathiyasivam  2007

In this tutorial I will show you how you can create an object oriented database abstraction class for MySQL database. Besides the basic functions this manager class can summarize total time spent with db connection and query execution and counts how many query were executed.
Step 1.
The first question is why we need at all such script if we have all function in PHP as default. There are more arguments:

• You can easy reuse the script in all of your development.
• You can change the database without changing all of your script. You need to edit only the abstraction class.
• You can make optimalisation and simplification more easy.
• You can centralize error handling and db access.
• You can make the debugging easier.
• You can easy implement query time statistics and query counters.

Now let’s summarize what kind of function do we need:

• Creating a connection to the database
• Executing sql queries
• Get the number of selected rows if possible
• Get the number of modified rows if possible
• Get the auto increment id of the latest insert statement if possible
• Load a query result into a normal array
• Get the error message and/or id if necessary
• Get the total time spent in the database
• Get the number of the executed queries

Step 2.
Before we can start the implementation of the functions we need to collect all common used class variables which stores important information.
These are:

• A connection identifier to store the actual connection link.
• A result Set to store query results.
• An error message and error id to store error information.
• A counter to count executed queries.
• A time counter to store total query times.

So the basic DB manager class looks like this:

[source:php]

<?php

class DBManager{

var $connection = ”;
var $queryCounter = 0;
var $totalTime = 0;
var $errorCode = 0;
var $errorMsg = ”;
var $resultSet = ”;

}
?>

[/source]

Step 3.
Now we can implement the functions. Let’s start with the most important one. Connecting to the database. We will create no stand alone connect script but the constructor of the class will be responsible to build up the database connection. So if you create a database object from this class you immediately have a valid connection as well.

So the constructor needs the following parameters:

• hostname
• username
• password
• database name

In the function first we try to connect to the database server and if it was success than we try to select the given database. In case of any error we set the error message and error id variables and return with false.

The constructor of the class is the following:
[source:php]
<?php
function DBManager($host, $user, $pass, $db){
$startTime = $this->getMicroTime();

// Try to make a connection to the server
if (!$this->connection = @mysql_connect($host,$user,$pass,true)){
$this->errorCode = mysql_errno();
$this->errorMsg = mysql_error();
return false;
}

// Now select the database
if (!@mysql_select_db($db,$this->connection)){
$this->errorCode = mysql_errno();
$this->errorMsg = mysql_error();
@mysql_close($this->connection);
return false;
}

$this->totalTime += $this->getMicroTime() – $startTime;

return true;
}
?>
[/source]
Step 4.
As next step we will implement the query execution function. In this function we measure the execution time (see details later), increasing the query counter and of course executing the query itself. If an error occurs than we set the error message and error id variables and returns with false. If everything was working fine we return with the result set.

The code is the following:
[source:php]
<?php
function executeQuery($sql){
$startTime = $this->getMicroTime();

++$this->queryCounter;

if(!$this->resultSet = @mysql_query($sql,$this->connection)){
$this->errorCode = mysql_errno();
$this->errorMsg = mysql_error();
$this->totalTime = $this->getMicroTime() – $startTime;
return false;
}

$this->totalTime += $this->getMicroTime() – $startTime;

return $this->resultSet;
}
?>
[/source]
If the query contains an Insert, Update or Delete command than it can be important to know how many records were affected by this query. To get it we implement a function for that as follows:
[source:php]
<?php
function getAffectedRows()
{
return @mysql_affected_rows($this->connection);
}
?>
[/source]
In case of a Select statement the number of selected records could be interesting. To get it we have a similar function:
[source:php]
<?php
function getSelectedRows()
{
return @mysql_num_rows($this->resultSet);
}
?>
[/source]
In this topic we have a last important issue. In case of Insert maybe we want to know an auto increment filed value. To get this information after the record was inserted we can use the following code:
[source:php]
<?php
function getInsertId(){
return @mysql_insert_id($this->connection);
}
?>
[/source]
Step 5.
Now let’s create some other useful function to make our class more usable.
In case of a select it sometimes it would be nice to get an associative array instead of the MySQL result set. So we implement a function which returns with such an array generated from the actual result set.
The code looks like this:
[source:php]
<?php
function loadResult() {
$array = array();
while ($row = mysql_fetch_object( $this->resultSet )) {
$array[] = $row;
}
mysql_free_result( $this->resultSet );

return $array;
}
?>
[/source]
As our function don’t send error messages back to the caller just sets the error variables inside the class so we need function to get this information. These are simple getter functions as follows:
[source:php]
<?php
function getErrrorCode(){
return $this->errorCode;
}

function getErrorMessage(){
return $this->errorMsg;
}
?>
[/source]

Step 6.
As final step we need to implement a function to get query times. To do it we need a function which returns the actual time in milliseconds. With calling this function at the beginning and at the end of the affected db functions we can calculate the total db time. Besides this we implement 2 other getter functions to get the number of executed queries and the total query time in a usable format.

So our helper functions looks like this:
[source:php]
<?php
function getDBTime(){
return round($this->totalTime,6);
}

function getSqlCount(){
return $this->queryCounter;
}

function getMicroTime() {
list($usec, $sec) = explode(” “,microtime());
return ((float)$usec + (float)$sec);
}
?>

[/source]

Copyright @ PHP Toys 2007

Here”s a list of queries that I found myself using very often and that save me a lot of development time. I hope you can benefit from them as well.

1. Create a quick backup

Before testing a new piece of code you suspect might mess up data in one or more tables it”s always a good practice to create a backup. To quickly create a backup copy of a table, use this query:

[source:sql]

CREATE TABLE backup SELECT * FROM TABLE original;

[/source]

The query creates a table backup which is a copy of the original table and includes both structure and content.

2. Create/change/restore a password

Many applications store MD5-crypted passwords in the database. If you want to quickly create a new MD5-ed password, or you have forgotten your password, use the following query to get a new one:

[source:sql]

SELECT MD5(“somepasshere”);

[/source]

This statement will give you “b5bab206cc8002bf7c10d47b24a2d0e6″ which is the encrypted version of the string “somepasshere”. There are other function that crypt stings in MySQL using different algorithms, most notably PASSWORD() which is using MySQL”s own crypting algorithm.

3. Working with Unix timestamps

To convert from human-readable MySQL date/time format into Unix timestamp, use: SELECT UNIX_TIMESTAMP(); Without parameters, this will give you the timestamp of the current date and time. With parameters, you can get timestamp for any date. For example: SELECT UNIX_TIMESTAMP(“2006-12-31″); This statement gives you the timestamp 1167541200. To get a date back from a timestamp, use: SELECT FROM_UNIXTIME(1167541200); This results in “2006-12-31 00:00:00″

4. Quick increment

To increment an integer stored in a table (useful for stats for example), use: UPDATE sometable SET counter=counter+1 WHERE …; Here “counter” is the name of the field that stores the integer value.

5. Toggle a value

If you have a field that stores a Boolean type of value, like 0/1 or yes/no, you can easily toggle the value with one if-statement:

[source:sql]

UPDATE sometable SET flag=(IF(flag=”no”,”yes”,”no”));

[/source]

6. Find/replace

Say you want to update a piece of text if all records in a table field. REPLACE() comes to the rescue:

[source:sql]

UPDATE sometable SET field = REPLACE(field, “black”,”white”);

[/source]

This statement will replace all occurrences of the string “black” with the string “white” in all records of the “field” column. Apart from the string “white” the rest of the text contained in the field will be left as is.

7. Get a random record

If you want to select a random row in your table, you can use the statement:

[source:sql]

SELECT * FROM table ORDER BY RAND();

[/source]

8. Upper/lower case

If you want to modify a value and make it upper or lowercase, use the UPPER or LOWER functions, like this:

[source:sql]

SELECT LOWER(“Value”); // gives you “value”

SELECT UPPER(“Value”); // gives you “VALUE”

[/source]

I hope you learned something new today which will make your everyday life as a developer just a bit easier. Thank you for reading!

Author: Stoyan Stefanov is a web developer from Montreal, Canada, Zend Certified Engineer