I wanted to point out a few of the great database talks:

• State of MariaDB – Monty Widenius
• Cassandra: Strategies for Distributed Data Storage – Kelvin Kakugawa
• Developing Replication Plugins for Drizzle – Padraig O’Sullivan
• Drizzle, Scaling MySQL for the Future – Brian Aker
• SELECT * FROM Internet Using YQL – Jonathan LeBlanc
• Introduction to MongoDB – Michael Dirolf
• Introduction to PostgreSQL – Christophe Pettus, Josh Berkus
• Relational vs. Non-Relational – Josh Berkus
• Stacks of Cache – Duncan Beevers
• CouchApp Evently Guided Hack w/ CouchDB – J Chris Anderson

Beyond the DB talks, I’m also exited for a few other talks around high performance and high availability, from Facebook operations to Rasmus Lerdorf’s talk on making your PHP applications faster. I’ll also take the opportunity to shamelessly plug my own talk on writing high performance multi-core applications. There are also rumors of donut trucks, tesla coils, and scavenger hunts.

You should register to attend today, it’s going to be awesome.

View full post on Planet Drizzle

Title	Presenter	Slides	Video link (hr:min:sec)	Details (Conf. site link)
Main Stage
Keynote: Under New Management: Next Steps for the Community	Sheeri K. Cabral (Pythian)	N/A	18:16	session 14808
Ignite talk: MySQLtuner 2.0	Sheeri K. Cabral (Pythian)	PDF	5:31	N/A
Interview
Thoughts on Drizzle and MySQL	Sheeri K. Cabral (Pythian)	N/A	9:22	N/A
Tutorials
MySQL Configuration Options and Files: Basic MySQL Variables (Part 1)	Sheeri K. Cabral (Pythian)	PDF	1:25:04, pre-break 1:35:47, post-break	session 12408
MySQL Configuration Options and Files: Intermediate MySQL Variables (Part 2)	Sheeri K. Cabral (Pythian)	PDF	1:25:04, pre-break 1:24:28, post-break	session 12435
Sessions
Better Database Debugging for Shorter Downtimes	Rob Hamel (Pythian)	PDF	33:13	session 13021
Find Query Problems Proactively With Query Reviews

Sheeri K. Cabral (Pythian) PDF 45:59 session 13267 Time Zones and MySQL Sheeri K. Cabral (Pythian) PDF 45:54 session 12412 Security Around MySQL Danil Zburivsky (The Pythian Group) ODP 37:27 session 13458 Continual Replication Sync Danil Zburivsky (The Pythian Group) ODP 45:57 session 13428

View full post on Planet Drizzle

Read more on PRWeb via Yahoo! News

• Morgan Tocker, Baron Schwartz: Diagnosing and Fixing MySQL Performance Problems
• Peter Zaitsev: Scaling Applications with Caching, Sharding and Replication
• Baron Schwartz: EXPLAIN Demystified
• Vadim Tkachenko: An Overview of Flash Storage for Databases
• Matt Yonkovit: The Five Minute DBA
• Bill Schuler, Baron Schwartz: Performance and Feature Enhancements to MySQL and InnoDB
• Fernando Ipar: PHP Object-Relational Mapping Libraries In Action
• Baron Schwartz: Read-Write Splitting: Techniques, Challenges, and Solutions
• Matt Yonkovit, Yves Trudeau: Choosing the Right Tools for the Job, SQL or NOSQL
• Vadim Tkachenko, et al: Panel: How Solid-state Technologies are Transforming MySQL Server Performance and the Datacenter Architectures
• Morgan Tocker: Understanding the Role of IO As a Bottleneck
• Baron Schwartz: MySQL Graphing and Trending with Cacti
• Vadim Tkachenko: XtraBackup: Hot Backups and More
• Aleksandr Kuzminsky: Recovery of Lost or Corrupted InnoDB Tables
• Ryan Lowe: Achieving PCI Compliance with MySQL
• Yves Trudeau: How to choose High Availability solutions for MySQL
• Yasufumi Kinoshita: How to Fulfil the Potential of InnoDB’s Performance and Scalability
• Peter Zaitsev: Choosing Hardware and Operating Systems for MySQL
• Peter Zaitsev: Instrumenting your Application for MySQL and Memcached
• Peter Zaitsev: InnoDB Architecture and Performance Optimization – Part 1 and InnoDB Architecture and Performance Optimization – Part 2

In addition, you’ll be able to visit us at our booth in the expo hall, where you can play Stump The Experts with your tough problems. And Daniel Nichter will be staffing the Maatkit booth, so you can ask him all about Maatkit. If Maatkit is of interest to you, you might also want to attend the Maatkit BoF session.

We look forward to seeing you there. It’s going to be a great conference!

Entry posted by Baron Schwartz |
No comment

Add to: | | | |

View full post on MySQL Performance Blog

PHP 101: PHP FINDING KEYS WITHIN SESSIONS USING ISSET() AND ARRAY_KEY_EXISTS()

Written by: Robert Guida, guidaMedia.com, ©2009.

The isset function is a staple utility of PHP to make sure sessions variables exist before accessing them. Unless you are familiar with session variables, even after reading about them on php.net, this lesson will help you gain a better understanding on how to check the existence of a session key.

We will test different uses of isset to see the results. Some you may expect, while others may surprise you. After looking at isset the lesson tests array_key_exists, to show how the function can be utilized in your code. We will look at simple single-depth sessions and multi-dimension sessions. By single-depth session I am referring to a session key that is at the first level, $_SESSION["key"]. I also refer to this key as a parent key, as it can have a sub-key, like $_SESSION["key"]["sub-key"]. I refer to the sub-key as a child key. This is also what I mean by a mult-dimension session, as it has multiple layers.

Just a few notes about the tests: The full test is at the end of the article. You can copy and paste that into you editor and run it. You can also run each test separately. Running the full script provides formatting to easily review the results, while the individual test do not. You will notice that I provide two results for each test, however, only one is possible. I do this because I take more of an experimental approach to explaining the differences to provide a definitive understanding of how to access session keys.

Last note: We are testing sessions, so if you do not already know, this remains set until your session ends; when you close your browser. To avoid having to close the browser a unset function is included, so the key in the session is dropped.

Test 1

This first test examines the typical use of isset. However, test 1a uses isset with a session key that is not set, and 1b sets the key and runs the same test.

echo “

Test 1a: Testing ISSET on a key at the first level. The key is not set.

“;
if(isset($_SESSION["PHP_SESSION"])){
echo “

Yes, the key PHP is set, however it was never set.

“;
}else{
echo “

No, the key PHP is not set.

“;
}
echo “

Test 1b: Testing ISSET on a key at the first level. The key is set.

“;
$_SESSION["PHP_SESSION"] = “5″;
if(isset($_SESSION["PHP_SESSION"])){
echo “

Yes, the key PHP is set.

“;
}else{
echo “

No, the key PHP is not set, however it is set.

“;
}
unset($_SESSION["PHP_SESSION"]);

The results work as you probably expect. Test 1a returns “No”, while 1b returns “Yes”. 1a returns “No” because we have not yet set the key “PHP_SESSION”. When it is set for 1b, isset finds the key is set.

So, let’s continue testing, and see what happens when use isset with a child key that has a value.

Test 2

In this test we look at the results of using ISSET on a child key. We test if the child key is set, as well, if it is not set. Here again we get some expected results.

echo “

Test 2a: Testing ISSET on a child key. The child key is set.

“;
$_SESSION["PHP_SESSION"]["ISSET"] = “Setting the child key, ‘PHP SESSION ISSET’”;
if(isset($_SESSION["PHP_SESSION"]["ISSET"])){
echo “

Yes, it appears the child key is set. The result is the same as test 2a.

“;
}else{
echo “

The result is false.

“;
}
echo “

Test 2b: Testing NOT ISSET on a child key. The child key is set.

“;
if(!isset($_SESSION["PHP_SESSION"]["ISSET"])){
echo “

The result is false.

“;
}else{
echo “

Yes, it appears the child key is set. The result is the same as test 2b.

“;
}
unset($_SESSION["PHP_SESSION"]);

Test 2a results in “Yes”, and so does test 2b. This is expected. So why test if not isset? To answer this, lets look at Test 3, and mix it up a little.

Test 3

This test uses the same tests from Test 2, but we unset the child key. Let see what our results are.

echo “

Test 3a: Testing ISSET on a child key. The child key is not set.

“;
$_SESSION["PHP_SESSION"] = “Setting the parent key PHP SESSION”;
if(isset($_SESSION["PHP_SESSION"]["ISSET"])){
echo “

Yes, it appears the child key is set.

“;
}else{
echo “

The result is false.

“;
}
echo “

Test 3b: Testing NOT ISSET on a child key. The child key is not set.

“;
if(!isset($_SESSION["PHP_SESSION"]["ISSET"])){
echo “

The result is false.

“;
}else{
echo “

Yes, it appears the child key is set.

“;
}
unset($_SESSION["PHP_SESSION"]);

The results we get in test 3 are the same as test 2. Why is this? Let’s look at the definition of the isset function from php.net:

“Evaluation goes from left to right and stops as soon as an unset variable is encountered.”

What this means is, the isset function checks the parent key, then it looks for the child key, which is to the right of the parent. Thus, it looks left to right. Since the child key is not set, the search stops, and the isset value for the parent key is returned rather than the child. Since the parent value is set, the result is “true”.

Test 2 and 3 shows us that using isset on a child key is not reliable, since the results you get are the same when it is set, as when it is not? This is where array_key_exists come in to the rescue.

Again, to ensure you have a definitive understanding of array_key_exists, we examine different uses of this function. Once done, you should know how to use array_key_exists.

Test 4

This test looks at using array_key_exists on a parent key, and then a child key.

echo “

Test 4a: Testing ARRAY_KEY_EXISTS on a parent key. The parent key is set.

“;
$_SESSION["PHP_SESSION"]["AKE"] = “Setting the child key, ‘PHP SESSION AKE’”;
if(array_key_exists(“PHP_SESSION”, $_SESSION)){
echo “

Yes, the parent key exists.

“;
}else{
echo “

The result is false.

“;
}
echo “

Test 4b: Testing ARRAY_KEY_EXISTS on a child key. The child key is set.

“;
if(array_key_exists(“AKE”, $_SESSION)){
echo “

The result is true, but ISSET does not exist at the parent key level.

“;
}else{
echo “

No, the child key does not exists because we are searching the wrong level.

“;
}

Test 4a returns true, while test 4b doesn’t. In order to find the child key, the session and the parent key, $_SESSION["PHP_SESSION"], must be used in the search. The next test shows us how to successfully use array_key_exists.

Test 5

This example shows how to test the session for a child key. By including the parent key in the search, we find the child key.

echo “

Test 5: Testing ARRAY_KEY_EXISTS on a child key, using the parent key in the search. The child key is set.

“;
if(array_key_exists(“AKE”, $_SESSION["PHP_SESSION"])){
echo “

Yes, the child key exists, because we are searching the parent key, PHP SESSION.

“;
}else{
echo “

The result is false.

“;
}

$string = “This is a string to see the results when isset and array_key_exists are used on non array type variables, such as
a string.”;
echo “

Test 6a: What happens when we use isset on a string.

“;
if(isset($string)){
echo “

The variable is set.

“;
}else{
echo “

The result is false.

“;
}
echo “

Test 6b: What happens when we use array_key_exists on a string.

“;
if(array_key_exists(“results”, $string)){
echo “

The variable is set.

“;
}else{
echo “

The result is false. This will result in an error if error_reporting is not set to zero.

“;
}

The result: “Yes”. As mentioned, since the parent key is used in the search, the child is found. By adding the parent key, it directs the function to search inside the key.

So, now you may be wondering, what to use, array_key_exists, or isset. It really comes down to efficiency, reliability and choice. See, if you think for consistency sake using array_key_exists is the right choice, there are a few things to challenge that. One is, it appears the industry standard to use is isset. At least in all the code I have seen and worked with, that is the case. So there is a reason for that.

Could it be that if you end up passing a string into an array_key_exists function that the following error will be generated?

Warning: array_key_exists() [function.array-key-exists]: The second argument should be either an array or an object in Testing_ISSET_AKE_on_SESSIONS.php on line 95

That alone may be a good reason not to solely use array_key_exists. Isset does not throw an error. This test is included in the complete test at the end of the article.

I personally am used to using isset, because it is much easier to type. The only times I uses array_key_exists is when I am testing a child key. My formula, and my conclusion to this lesson is, I use isset whenever possible, but as soon as I need to test a child key, I use array_key_exists.

I hope this has helped you.

Here is the full testing code, or click here to go the actual PHP code.

<!–CTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN”

“http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>

<!–p

echo “

PHP FINDING KEYS WITHIN SESSIONS USING
ISSET() AND ARRAY_KEY_EXISTS()

“;

error_reporting(0);
echo “

Test 1a: Testing ISSET on a key at the first level. The key is not set.

“;
if(isset($_SESSION["PHP_SESSION"])){
echo “

Yes, the key PHP is set, however it was never set.

“;
}else{
echo “

No, the key PHP is not set.

“;
}
echo “

Test 1b: Testing ISSET on a key at the first level. The key is set.

“;
$_SESSION["PHP_SESSION"] = “5″;
if(isset($_SESSION["PHP_SESSION"])){
echo “

Yes, the key PHP is set.

“;
}else{
echo “

No, the key PHP is not set, however it is set.

“;
}
unset($_SESSION["PHP_SESSION"]);

echo “

Test 2a: Testing ISSET on a child key. The child key is set.

“;
$_SESSION["PHP_SESSION"]["ISSET"] = “Setting the child key, ‘PHP SESSION ISSET’”;
if(isset($_SESSION["PHP_SESSION"]["ISSET"])){
echo “

Yes, it appears the child key is set. The result is the same as test 2a.

“;
}else{
echo “

The result is false.

“;
}
echo “

Test 2b: Testing NOT ISSET on a child key. The child key is set.

“;
if(!isset($_SESSION["PHP_SESSION"]["ISSET"])){
echo “

The result is false.

“;
}else{
echo “

Yes, it appears the child key is set. The result is the same as test 2b.

“;
}
unset($_SESSION["PHP_SESSION"]);

echo “

Test 3a: Testing ISSET on a child key. The child key is not set.

“;
$_SESSION["PHP_SESSION"] = “Setting the parent key PHP SESSION”;
if(isset($_SESSION["PHP_SESSION"]["ISSET"])){
echo “

Yes, it appears the child key is set.

“;
}else{
echo “

The result is false.

“;
}
echo “

Test 3b: Testing NOT ISSET on a child key. The child key is not set.

“;
if(!isset($_SESSION["PHP_SESSION"]["ISSET"])){
echo “

The result is false.

“;
}else{
echo “

Yes, it appears the child key is set.

“;
}
unset($_SESSION["PHP_SESSION"]);

echo “

Test 4a: Testing ARRAY_KEY_EXISTS on a parent key. The parent key is set.

“;
$_SESSION["PHP_SESSION"]["AKE"] = “Setting the child key, ‘PHP SESSION AKE’”;
if(array_key_exists(“PHP_SESSION”, $_SESSION)){
echo “

Yes, the parent key exists.

“;
}else{
echo “

The result is false.

“;
}
echo “

Test 4b: Testing ARRAY_KEY_EXISTS on a child key. The child key is set.

“;
if(array_key_exists(“AKE”, $_SESSION)){
echo “

The result is true, but ISSET does not exist at the parent key level.

“;
}else{
echo “

No, the child key does not exists because we are searching the wrong level.

“;
}

echo “

Test 5: Testing ARRAY_KEY_EXISTS on a child key, using the parent key in the search. The child key is set.

“;
if(array_key_exists(“AKE”, $_SESSION["PHP_SESSION"])){
echo “

Yes, the child key exists, because we are searching the parent key, PHP SESSION.

“;
}else{
echo “

The result is false.

“;
}

$string = “This is a string to see the results when isset and array_key_exists are used on non array type variables, such as
a string.”;
echo “

Test 6a: What happens when we use isset on a string.

“;
if(isset($string)){
echo “

The variable is set.

“;
}else{
echo “

The result is false.

“;
}
echo “

Test 6b: What happens when we use array_key_exists on a string.

“;
if(array_key_exists(“results”, $string)){
echo “

The variable is set.

“;
}else{
echo “

The result is false. This will result in an error if error_reporting is not set to zero.

“;
}

error_reporting(E_ALL);
print_r($_SESSION);
unset($_SESSION["PHP_SESSION"]);
?>

Usually the main reason for doing this is because of sessions. For security reasons your browser will not keep you signed in with the same session if you hop subdomains. What this means is that if you logged in on www1.example.com and now go to www2.example.com the browser will consider this as two separate sites and you would have to login again on www2.

People used to play a number of tricks to remove session stickiness such as storing sessions in the db so that they could transparently load balance your session across multiple webservers. However databases due to their inherent nature are often large monolithic beasts that are much slower than some of the alternatives available out there now.

One of these, which I am a fan of, is memcache! The folks over at danga.com have given us one of the most powerful building blocks for creating highly scalable websites.

We can now experience load balancing as it was meant to be!

As an example lets take PHP session handling. PHP usually stores its session on the local hard drive of a server. You can also make it store sessions inside a database, lets say MySQL. However, as I mentioned earlier MySQL is very slow compared to memcache and is inherently harder to scale compared to memcache.

To setup PHP to use memcache for sessions, this is all you have to do :

0 – Install memcache library available at http://pecl.php.net/package/memcache

1 – Open php.ini

2 – Set session.save_handler = memcache

3 – Set session.save_path = “tcp://IP:PORT&weight=X” where X is the weight of a particular memcache server. You can add as many as you like by specifying one after the other separated by a comma.

4 – Install memcached. For a distribution like Fedora or CentOS just execute “yum install memcached”

All of this should not take you more than 5 minutes, and you are done!

Now to scale just keep adding more servers and firing up the memcached daemon  and experience the true beauty of completely transparent load balancing .