With SQL Azure right around the corner (expected to go live in November 2009), I had to evaluate if we could migrate some databases 'into the microsoft cloud'.

The pitch from Microsoft senior program manager David Robinson is "With SQL Azure, developers building Web 2.0, ASP.Net and PHP applications can use familiar tools and data models to develop on a pay-as-you-grow, secure, scalable and highly available database service at minimal infrastructure cost,".

First, there are limitations, but essentially microsoft is offering a subset of SQL server 2008 running on their infrastructure.

SQL Azure is the first hosted database product with good support for Transact-SQL. This means that any application using nearly standards compliant SQL queries could easily be migrated to use SQL Azure.

For example, using the MV framework, it could be as simple as changing your connection

PostgreSQL:

$db = MV_Database_Connection::create('pgsql://user:pass@localhost/database');

SQL Azure:

// Windows
$db = MV_Database_Connection::create('odbc_mssql://user:pass@DRIVER=Driver={SQL Server Native Client 10.0};Server=serverName.database.windows.net;Port=1433;Database=database;UID=user@serverName;PWD=pass;');

// Unix
$db = MV_Database_Connection::create('odbc_mssql://user:pass@DRIVER={FreeTDS};Server=serverName.database.windows.net;Port=1433;Database=database;UID=user@serverName;PWD=pass;TDS_Version=8.0;');

Since Microsoft has made it relatively easy to connect to SQL Azure from Windows (SQL Server Native Client), this post looks at connecting php5 on unix to SQL Azure.

There are two methods to connect to SQL Azure from UNIX.

a) Using mssql_connect()


// Install php5-mssql
// Check freetds version, v0.64 compiled with openssl or gnutls works with Azure

[root@dev] $ tsql -C
Compile-time settings (established with the "configure" script):
Version: freetds v0.64
MS db-lib source compatibility: no
Sybase binary compatibility: unknown
Thread safety: yes
iconv library: yes
TDS version: 5.0
iODBC: no
unixodbc: yes

// Add .conf entry so you can mssql_connect('AZURE', 'username', 'password');
// http://www.freetds.org/userguide/freetdsconf.htm#FREETDSCONFFORMAT

[root@dev] cat /usr/local/etc/freetds.conf
dump file = /tmp/freetds.log
debug level = 10
[AZURE]
host = serverName.database.windows.net
port = 1433
tds version = 8.0
client charset = UTF-8

b) Using odbc_connect()


// Install php5-obdc
// Check unixODBC version, 2.2.12 works well with PHP
[root@dev] $ isql --version
unixODBC 2.2.12

// Add the 'FreeTDS driver' so that unix obdc can use it
[root@dev] $ cat /usr/local/etc/odbcinst.ini
[FreeTDS]
Description = v0.64 with protocol v8.0
Driver = /usr/local/lib/libtdsodbc.so

// Add dsn entry that obdc can use, point to FreeTDS name...
// http://www.freetds.org/userguide/odbcconnattr.htm
[root@dev] $ cat /usr/local/etc/odbc.ini
[TestServer]
Driver = FreeTDS
Description = Azure test with FreeTDS
ServerName = AZURE
Database = gol

Once your unix server is properly configured, you can go ahead and test php connections.


// SQL Azure supports tabular data stream (TDS) protocol client version 7.3 or later
// @see http://msdn.microsoft.com/en-us/library/ee336245.aspx

// On unix, we can connect using open-source FreeTDS (http://www.freetds.org/).
// Replace XXX with your database information.
$serverName = 'XXXXXXXXXX';
$user = 'XXX@' . $serverName;
$pass = 'XXXXXX';

if(function_exists('mssql_connect')) {
// Using DSN name 'AZURE' (specified in /usr/local/etc/freetds.conf)
$c = mssql_connect('AZURE', $user, $pass);
echo "mssql_connect('AZURE', $user, $pass): ". ($c ? 'Success' : 'Error') . "
";
mssql_close($c);
sleep(1);
}

if(function_exists('odbc_connect')) {

// All examples require entry in /usr/local/etc/odbcinst.ini:
// [FreeTDS]
// Driver = /usr/local/lib/libtdsodbc.so

// Using DSN name 'TestServer' (specified in /usr/local/etc/odbc.ini)
$c = odbc_connect('TestServer', $user, $pass);
echo "odbc_connect('TestServer', $user, $pass): ". ($c ? 'Success' : 'Error') . "
";
odbc_close($c);
sleep(1);

// Using DSN name '$serverName' (specified in /usr/local/etc/freetds.conf)
$dsn = "DRIVER={FreeTDS};ServerName=$serverName;UID=$user;PWD=$pass;Database=test;";
$c = odbc_connect($dsn, $user, $pass);
echo "odbc_connect($dsn, $user, $pass): ". ($c ? 'Success' : 'Error' ) . "
";
odbc_close($c);
sleep(1);

// DSN-less connection (more portable / recommended)
$dsn = "DRIVER={FreeTDS};Server=$serverName.database.windows.net;Port=1433;Database=test;UID=$user;PWD=$pass;TDS_Version=8.0";
$c = odbc_connect($dsn, $user, $pass);
echo "odbc_connect($dsn, $user, $pass): ". ($c ? 'Success' : 'Error') . "
";
odbc_close($c);
sleep(1);

// **Note: Driver= must be uppercase!? Find out where the bug comes from!
// $dsn="Driver={FreeTDS};ServerName=AZURE;Database=gol;UID=$user;PWD=$pass;";
}

If all went well, you should see 'Success' everywhere.

Be sure to check the version of FreeTDS and unixODBC you are using! If you run into bugs with these tools, well report them or write a patch!

My conclusion, although FreeTDS works, it is not enterprise ready and needs some corporate backing. Naturally, this brings the question, what Microsoft is up to?

There's a really easy way to get PHP running on Google's app engine, see this great link:

http://www.webdigi.co.uk/blog/2009/run-php-on-the-google-app-engine/

In short, it works by using 'Quercus' which likely takes the php scripts, transforms and compiles into java bytecode that gets run in the JVM. Don't understand all that? No problem, the important note it is seems to work well.

So far I've tested two pieces of code:

Memcache

import com.google.appengine.api.memcache.MemcacheService;
import com.google.appengine.api.memcache.MemcacheServiceFactory;
import com.google.appengine.api.memcache.Expiration;

$service = MemcacheServiceFactory::getMemcacheService();

$expiration = Expiration::byDeltaSeconds(60);

echo 'MEMCACHE::get(): ' . $service->get("key1") . "
";

$service->put("key1", "hello", $expiration);

echo 'MEMCACHE::get(): ' . $service->get("key1") . "
";
?>


Works great.

Now, probably the most important reason to use App Engine? Access to your very own google database! Running scalable web services just got a whole lot easier.

The bad news is there's no good interface or classes yet with php, so you have to go through using google's 'raw' datastore API.

Datastore

import com.google.appengine.api.datastore;
import com.google.appengine.api.datastore.Entity;
import com.google.appengine.api.datastore.DatastoreServiceFactory;

$data = array('test' => 1,
'test2' => 2);

$entity = new Entity("MV_Storage_Php");
$entity->setProperty("value", serialize($data));

echo "KEY: ". (string)$entity->getKey(); // ok - unknown
echo "VALUE: ". (string)$entity->getProperty("value"); // ok

$dataService = DatastoreServiceFactory::getDatastoreService();

foreach($dataService->getActiveTransactions() as $t) {
echo "TRANS: ". $t->getId(); // none
}

$dataService->put($entity); // throws NULL exception!?

echo $entity->getKey();
?>


Unfortunately, it throws a NULL exception. So aside from the quirks, it looks promising.

The Datastore API is documented here.

When it comes to writing Web applications, a developer often needs to access data from a multitude of data sources. The result is often a lot of spaghetti code that iterates and filters the results (XML, csv, soap, REST services, and so on).

But the most common data that's accessed is in a relational database. Luckily, at some point database vendors agreed on SQL (standard query language) which is a common way to access /query data from a database.

With the reality of the Web, wouldn't it be nice to have some form of standard query language to access many forms of data?? That's what Microsoft's LINQ attempts to offer.

It's a great innovation and I was curious about what a PHP API could look like and it turns out there's a good discussion here:
http://www.mikeborozdin.com/post/Is-PHPLinq-As-Cool-As-Real-LINQ.aspx

The advantage of LINQ in .NET is how the LINQ expressions can be evaluated and compiled. In short, it takes the expressions ("pretty" code) and builds the "spaghetti code that iterates and filters the results" automatically. If the compiler is smart and can make proper machine level optimizations, I would guess it means very fast execution and a standard way of accessing data. Amazing!

As for PHP, Maarten Balliauw still went ahead and created a PHP implementation of LINQ:

http://www.codeplex.com/PHPLinq/Release/ProjectReleases.aspx?ReleaseId=10084

It's definetly "interesting" at this point and if PHP could support natively some form of LINQ, it would be a major achievement and very cool stuff.

There's also a java version of "LINQ" (Quaere):
http://www.theserverside.com/news/thread.tss?thread_id=46887

There's an RFC that has been recently declined through the PHP internals list. It is a minor change/patch to introduces a short synthax to declare arrays in PHP.

To declare an array in PHP, you currently use the following synthax:

$a = array('foo' => 'bar', 'nestarray' => array(0, 1, 5));


The proposed patch (a few lines) would allow to declare arrays in a shorter form:

$a = array('foo' => 'bar', 'nestarray' => array(0, 1, 5));

// New synthax
$a = ['foo'=> 'bar', 'nestarray'=> [0, 1, 5]];
// Or
$a = ['foo': 'bar', 'nestarray': [0, 1, 5]];


This notation is used by many programming languages, most notably javascript. Since PHP is essentially a programming language used for the Web, my opinion is it makes perfect sense to support a javascript-like notation for arrays.

There's some resistance from the core developers and overall there were too many veto (negative) votes. I definitely understand their concern but feel it's a natural evolution of the language, this to me seems like something most users would want to see in PHP.

Hopefully, the PHP community can speak out enough to get better idea of what the users / php community wants.

The actual proposal and more info at:
http://wiki.php.net/rfc/shortsyntaxforarrays.