Read the complete article

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

PHP Tricks For Beginners
In the Web 2.0 era, sites are all about the user – where they’re from, what they like, what they ate for breakfast. This means the best sites now include content tailored to users, and one way to do that is through the use of PHP. These simple tricks won’t set the world on fire, but they’re a peek into the possibilities of PHP.

Image generation in PHP using WPF
hp provides a number of graphical functions, but none is capable of creating rounded corners an gradients with ease. Everything has to be done by hand. WPF on the other hand uses xaml which supports everything you can think of in modern vector graphics design. Using a .NET assembly that takes a string of xaml and returns a PNG image would be the best in this case.

PHP multithreading using cURL
If you wanna get some information from servers using the protocols like http or ftp in PHP you can use cURL to do multithreading. Multithreading is a term used when we do more jobs in parallel. First I assume you know what cURL is and what you can it. If you are new to cURL, you can check one of my article on posting data with cURL , it will give you a brief intro to cURL.

Create a TinyURL with PHP
TinyURL is an awesome service. For those who don’t know what TinyURL is, TinyURL allows you to take a long URL like “http://davidwalsh.name/jquery-link-nudging” and turn it into “http://tinyurl.com/67c4se”. Using the PHP and TinyURL API, you can create these tiny URLs on the fly!

PHP performance: error suppression
A common misconception in the PHP community is that the @ operator is slow. It’s not. The real culprit is the generated error itself.

Communicating with Flex and PHP over Sockets
There are a number of ways to communicate between Flex and PHP but one of the more interesting is over sockets. Socket communication lets developers create near real-time communication by pushing information directly to the client. In this article you’ll see the basics of how to use PHP as the socket server and connect it to a Flex application.

Two ways to test for prime numbers in PHP: Sieve and File
n PHP is really no ideal way to test large integers and determine whether they are prime numbers or not. The most popular algorithm for finding prime numbers is a memory and resource hog. It is called The Sieve of Eratosthenes. Besides the Sieve I also implemented a prime number test by initializing an array of prime numbers from a file that contains the first 100,000 prime numbers. This is of course much faster, but would require files that contain all prime numbers up to a specific large number. The files of course could be partitioned, which would also increase performance.

PHP compiler performance
With the release of Facebook HipHop PHP compiler, the matters of performance of PHP compilers and runtime engines gained special relevance. This article presents a performance comparison of between different PHP compilers and runtime PHP execution engines, so we can evaluate what is the best solution that can be used in different PHP environments.

MongoDB and PHP – A Quick Look at GridFS
About 2 months ago we (LightCube Solutions) decided to install and mess around with MongoDB. We went from messing around to serious adoption about 2 weeks ago when we realized the power of working with it and PHP. It was Mitch Pirtle that first pointed us in this direction. Mitch was very enthusiastic about Mongo as he explained the great potential. Yet, it was only until I added an array of data from PHP into Mongo that my eyes started to open up.

Converting and optimizing SQL Statements
Now it became time to conveert some SQL statements. Even though many SELECT SQL statements will run unchanged in MYSQL it might be wise to check and see if they are performing well. There are some differences in how VFP and MYSQL optimize queries and a query that just performs great in VFP might be very slow in MYSQL. And then there are some cases where we have to replace things that are possible in VFP but not supported in MYSQL.

Mysql Tutorial – create table in database
If you are a learner (new) in PHP / Mysql and don’t know how to create table in Mysql database from php file than Here is the easiest and error-free way to create table in Mysql database. see more with an example..

8 basics of regular expression that can make you expert
Well, regular expressions have been something that I was scared of when I started coding as a serious stuff

Five Fabulous PHP Frameworks
Today’s web developer must be well-equipped in order to fully harness the enormous horsepower and features at his disposal, not to mention satisfy the tastes of an increasingly finicky user. While taking advantage of a powerful development environment such as NetBeans or PDT certainly helps, it’s also imperative to embrace sound practices that ensure high quality, testable code written with a minimum investment of time and effort.

What’s the Right Way to Prevent SQL Injection in PHP Scripts?
How to prevent SQL injection in PHP scripts is probably a topic that doesn’t need anything more written about it.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

IDC is one such group of experts and they recently released an interesting set of predictions on where databases – and specifically data warehouses and analytic DB’s – are going. You can read the quick update they issued HERE.

A couple of their ‘within 5 year’ predictions I found particular interesting for MySQL data warehouse users are:

• Most data warehouses will be stored in a columnar fashion
• Most large-scale database servers will achieve horizontal scalability through clustering

This is helpful information for MySQL users who want to ensure they’re making the right bets on their data warehouse designs and the storage engines they’re choosing. It’s also good news because MySQL users now have a choice of column databases they can try out and see which is right for them.

I’ve written a new article on the MySQL dev zone on why you should check out a column database if you’re planning to implement a data warehouse, reporting database, or any read-intensive application. It talks about the why and why not’s of column DB’s, discusses why they matter, and provides some interesting benchmark tests of a leading row database vs. InfiniDB.

You can find the new article HERE. Please let us know what you think and what plans you have for your data warehouses.

From: InfiniDB

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

InnoDB: In a MySQL replication slave the last master binlog file
InnoDB: position 0 10000000, file name mysql-bin.005000
InnoDB: Last MySQL binlog file position 0 20000000, file name ./mysql-bin.003000

He has tried to restart replication from mysql-bin.005000 position 10000000 which failed with “Could not find first log file name in binary log index file” error message

Looking at the Master for this slave I could see its binary log files going only to about 2000, so the binary log file mentioned did not ever exist on this master. What is going on ?
The thing is Innodb does not update this information any more however if it is stored in the tablespace the code is still there to print it. This database was running older MySQL version a while back which was updated to MySQL 5.1 months ago, moved to the new hardware by physical copy and the log file numbers restarted back from 1 but tablespace still contained the ancient data.

I reported the bug on this which should be easy to fix. Otherwise it is easy mistake to make. We also have a patch which restores this information and uses it on slave crash recovery.

From: MySQL Performance Blog

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

But before we look into how BLOBs are really stored lets see what misconception is about. A lot of people seems to think for standard (”Antelope”) format first 768 bytes are stored in the row itself while rest is stored in external pages, which would make such blobs really bad. I even seen a solution to store several smaller blobs or varchar fields which are when concatenated to get the real data. This is not exactly what happens

With COMPACT and REDUNDANT row formats (used in before Innodb plugin and named “Antelope” in Innodb Plugin and XtraDB) Innodb would try to fit the whole row onto Innodb page. At least 2 rows have to fit to each page plus some page data, which makes the limit about 8000 bytes. If row fits completely Innodb will store it on the page and not use external blob storage pages. For example 7KB blob can be stored on the page. However if row does not fit on the page, for example containing two 7KB blobs Innodb will have to pick some of them and store them in external blob pages. It however will keep at least 768 bytes from each of the BLOBs on the row page itself. With two of 7KB blobs we will have one blob stored on the page completely while another will have 768 bytes stored on the row page and the remainder at external page.

Such decision to store first 768 bytes of the BLOB may look strange, especially as MySQL internally has no optimizations to read portions of the blob – it is either read completely or not at all, so the 768 bytes on the row page is a little use – if BLOB is accessed external page will always have to be read. This decision seems to be rooted in desire to keep code simple while implementing initial BLOB support for Innodb – BLOB can have prefix index and it was easier to implement index BLOBs if their prefix is always stored on the row page.

This decision also causes strange data storage “bugs” – you can store 200K BLOB easily, however you can’t store 20 of 10K blobs. Why ? Because each of them will try to store 768 bytes on the row page itself and it will not fit.

Another thing to beware with Innodb BLOB storage is the fact external blob pages are not shared among the blobs. Each blob, even if it has 1 byte which does not fit on the page will have its own 16K allocated. This can be pretty inefficient so I’d recommend avoiding multiple large blobs per row when possible. Much better decision in many cases could be combine data in the single large Blob (and potentially compress it)

If all columns do not fit to the page completely Innodb will automatically chose some of them to be on the page and some stored externally. This is not clearly documented neither can be hinted or seen. Furthermore depending on column sizes it may vary for different rows. I wish Innodb would have some way to tune it allowing me to force actively read columns for inline store while push some others to external storage. May be one day we’ll come to implementing this in XtraDB

So BLOB storage was not very efficient in REDUNDANT (MySQL 4.1 and below) and COMPACT (MySQL 5.0 and above) format and the fix comes with Innodb Plugin in “Barracuda” format and ROW_FORMAT=DYNAMIC. In this format Innodb stores either whole blob on the row page or only 20 bytes BLOB pointer giving preference to smaller columns to be stored on the page, which is reasonable as you can store more of them. BLOBs can have prefix index but this no more requires column prefix to be stored on the page – you can build prefix indexes on blobs which are often stored outside the page.

COMPRESSED row format is similar to DYNAMIC when it comes to handling blobs and will use the same strategy storing BLOBs completely off page. It however will always compress blobs which do not fit to the row page, even if KEY_BLOCK_SIZE is not specified and compression for normal data and index pages is not enabled.

If you’re interested to learn more about Innodb row format check out this page in Innodb docs:

It is worth to note I use BLOB here in a very general term. From storage prospective BLOB, TEXT as well as long VARCHAR are handled same way by Innodb. This is why Innodb manual calls it “long columns” rather than BLOBs.

From: MySQL Performance Blog

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Let me start with couple of comments about Jays article. First – caching in files should be used with caution. It may be very efficient especially if number of cached objects is small but if you get too many small objects which need to be cached files can become inefficient, especially if you do not care about putting them into different directories on file systems which can’t handle too many files in the same directory efficiently. The other problem with files is of course being local to the local node which might be inefficient with many web servers. Putting cache on shared storage could work but that is extra complication. There are cases when file cache works pretty well – for example caching full page results in files can be extremely efficient, especially if you can ofload sending cache result to the client by web server (instead of doing it from PHP). The other case when caching in files can be very helpful is caching data long term – ie if you got it from some Web Service. For smaller short lived objects things like memcached (or local shared memory for small installations) can be more efficient.

Lets now get to the main point of this article – I wanted to talk in a bit more details about caching algorithms and for which kind of application each of them can work.

TTL Based Caching This is probably most common approach for cache organization in the Web – you cache the object and say it is going to expire in 60 seconds. This type of caching is even supported by HTTP protocol with its Expires Header. This approach to the caching is very simple and pretty efficient, however it leads to having stale data which is problematic for some applications, also objects may expire before they are really modified so cache can be less efficient than possible. TTL caching is great if you have no way to know when object has changed. For example if you retrieve product information from Amazon Web Services, you have no way to get notification about it being changed so the only thing you can do is check if it was changed every so often.

Cache Invalidate With this apporach you invalidate or remove objects in cache once underlying information is updated. This is how MySQL Query Cache works by removing all queries derived from the table if that table is updated. This technique requires you to know which objects are based on which data so you can invalidate wisely and of course have update notifications. This cache can be more efficient with rare updates but you better to have fine grain control of what has to be invalidated – approach used by MySQL Query Cache is too coarse invalidating a lot of queries which really do not need to be. The other problem with this method is – invalidation can be expensive, especially if you get many objects cached and they are stored on the storage or network rather than local memory. This approach works very well if you cache is structured so each update removes only one object from the cache.

Cache Update This one is quite similar to cache-invalidate approach but with difference what cache content is actually renewed rather than invalidated. This approach is more efficient, especially if renewing is done in background as it greatly reduces number of cache misses, while it also wastes resources by updating what might never be needed again. Another complication for this approach is – cache has to become active and know how to update cache content rather than being simply storage system. You can also mix cache update and cache-invalidate approaches efficiently. For example I worked with one company having trouble with some Full Text Search requests – they just were way to slow, while some of them was very frequent. Until Full Text itself could be optimized we added cache update algorithm which would populate cache with result set for most frequent and complicated queries as new data is loaded and index is rebuilt.

Version based caching This could be thought about as modification of previous ones but I will put it as separate item as it is quite efficient way to organize things. In this case version is associated with each of the data sources used to compose the object. For each of the object data source versions are stored together with cached data. Once you take object out of cache you validate if all versions are still current and use it or throw it away. The good thing about this approach is – you cache operations have constant complexity – you do not have to do big invalidation clean up on updates. Let me come with example how it can work in practice. Lets say you’re running big blogging site which has many blogs published. You may store blog version which is updated on each blog modification and have all cache lookups for this user to check if blog version has chaged. You can become more fine grained and have versions added to blog entries so if comment is added to post B you do not invalidate post A. Of course this method also has its downsides – you have to perform extra version check on each lookup and it might be complicated and caching bugs hard to debug, but it can give very good cache efficiency for some applications.

These are of course only some of the approaches which you can use, and in many cases mixing them may make sense. You may use TTL for some of the objects while invalidation for others.

Thanks to: MySQL Performance Blog

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Monitoring your MySQL errors
Great tutorial on how to monitor your MySQL Server for errors.

New OLAP Wikistat benchmark: Introduction and call for feedbacks
Article about a new benchmark.

How to use MySQL cluster
MySQL Cluster can be used as a general purpose transactional storage engine, but if you convert all your InnoDB tables to it and connect your application straight to it you may not see the performance you were hoping for.  This is because MySQL Cluster was originally designed for real-time telecommunications applications (such as RADIUS servers).  It has slowly been modified to become more general purpose and improvements are being made every day but there are still some performance considerations which go with this.  In some cases tweaking your schema and/or queries can help performance dramatically, so I shall try and outline some of things to watch for here.

innodb_file_per_table, shrinking table spaces and the data dictionary
INNODB has some irritating gotchas that makes disk space management hard. In 2002ish INNODB, added innodb_file_per_table to get around allot of these issues, but it does not fix everything.

10x Performance Improvements in MySQL – A Case Study
Slideshow with tips on how to improve the performance of your MySQL server

SHOW TEMPORARY TABLES
I had this patch for a while where one can get listing of both session and global temporary tables across all sessions. It really helped lot of times to understand the bottlenecks of some of the temporary table issues as MySQL never exposed them in the form of SHOW TABLES.

Fun with Table Functions
Great tricks on how to use table functions.

Join on overlapping date ranges
Query example how to join data with overlapping date ranges.

Beware of implicit casting
Ever so often a query provides a “bad” execution plan. Adding a missing index can many times solve the problem. However, not everything can be solved with an index. I wish to highlight the point of having an implicit cast, which negates the use of an index on MySQL.

What is CHECK TABLE doing with InnoDB tables?
Find out in this article what CHECK TABLE is doing with InnoDB table.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

They might have done better to search for Oracle’s point person on MySQL, Ken Jacobs.

On Friday, Jacobs announced his resignation from Oracle to key members of the MySQL team via e-mail. Jacobs, a 28-year Oracle veteran and one of its first 20 hires, has been Oracle’s liaison with the MySQL community for the past several years, ever since Oracle acquired the popular MySQL storage engine, InnoDB.

While Jacobs doesn’t give an explicit reason for his departure, he does hint at disappointment that he was not selected to run MySQL’s database business post-acquisition. “I imagine you all know that I will not be leading the MySQL GBU, as I had expected,” he said.

I share that disappointment.

I, among others, worried that Oracle’s acquisition of InnoDB effectively amounted to a hostile takeover of MySQL’s financial fortunes, but such has not been the case. Arguably, Jacobs is a primary reason that Oracle’s ownership of InnoDB has been peaceful, not a declaration of war.

I don’t expect Jacobs’ departure to significantly alter Oracle’s plans for MySQL, which I believe to be good (the temporary absence of source code notwithstanding), but I do worry that his thoughtful interaction with the open-source community will be missed.

Jacobs, himself, in his departure e-mail, noted the benefits MySQL will receive from Oracle’s ownership:

I know that there are many people in the open source community who are concerned about Oracle’s plans for MySQL. They are wrong to worry. Oracle will keep its commitments to invest in MySQL, and help grow the business. Oracle will make MySQL better. Doing so gives Oracle a presence in new markets, and the resources and investment Oracle will make should mean great things for customers, as well as the larger community.

You will find Oracle a terrific place to work! I believe it is good for MySQL (the product, the company, the people and the community) that you are now part of a software company. And a database company. And a company that is profitable, and that innovates and delivers high customer satisfaction. That’s where MySQL belongs!

Edward Screven, Oracle’s chief corporate architect, will be overseeing all-things-open-source at Oracle, leaving less room for Jacobs but also demonstrating Oracle’s positive intentions for MySQL. Screven reports directly to Oracle CEO Larry Ellison and should be a good advocate for MySQL within the company.

Even so, I will miss Jacobs. I have had many interactions with him over the years, and he has always proved to be a thoughtful, measured advocate for and defender of Oracle. His influence will be missed at Oracle as it takes on the arduous task of managing the world’s largest database community.

From: CNet

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Triggering Cascading Updates and Deletions with Foreign Key Constraints
Cool article how to create cascading updates and deletions on your MySQL database using key constraints.

Create Pivot Tables in PHP
Tutorial on how you can use PHP to create Pivot Tables.

Working in the Method Scope with Static Variables in PHP 5 Classes
Despite their name, static properties can help in a wide variety of situations. If you’re not using them currently, and you regularly implement design patterns in your code, after reading this series you’ll wonder how you ever did without them.

PHP mistakes, misconceptions, bad practices and blatant no nos.
Go to any PHP help forum and you’ll be sure to see many bad practises, innocent misconceptions and blatant no nos. None of us are perfect and none of us started off writing great code. We have all had that moment where we looked back on a script that we wrote years ago and thought “what the hell was I thinking?”. But it is a process. You make mistakes, you learn from those mistakes and then you move on.

Practical Php Patterns: Composite
One of the most important structural patterns is the Composite one: its goal is managing a hierarchy of objects where both leaf objects and composition of other objects conform to a common interface. This hierarchy is usually constituted by part-whole relationships (often composition in the strict sense or aggregation), and it can be viewed as a tree.

Relationships between objects
Clear article where relationships between objects are explained.

Implementing Factory Methods in PHP 5
If you’ve ever developed desktop applications using mature object-oriented languages like C++ and Java, then it’s possible that you’ve found yourself saying a few funny phrases such as “I need to implement a factory method within this class,” or in the worst case: “this class needs to implement a factory method, but I don’t have a single clue about how to do that.” Surprisingly, you can implement these factory methods pretty quickly and easily in PHP 5.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.