The problem with this is the process of saving inside the program. Should it be done every time the stored data is modified? But then, what happens when the data is modified 100+ times per second? The application would attempt to encode the data, and write it to the device 100 times per second. The iPhone would simply crash in this situation (on the simulator it would even be slow! this is an extreme example). Another solution is to provide a superclass to data managing objects, which could control a batch-flow workspace. They could store a boolean as to whether the data should be saved each step or not. Then the saving would look like this:

Disable saving
Run loop - modify a bunch of data
Enable saving (this would also save the data)

By default, saving should be switched on. Personally, I’d name the methods something like as follows:

[dataObject beginBatchModifications];
for (unsigned i = 0; i < 100; i ++) {
    [dataObject removeObjectAtIndex:i];
}
[dataObject finishBatchModificationsAndSave];

This is not a perfect solution, but provides a neat code when finished. ]]> http://ryanjd.com/index.php/archiving-data/feed/ 1 http://ryanjd.com/index.php/uitableview-reloaddata-not-working/ http://ryanjd.com/index.php/uitableview-reloaddata-not-working/#comments Sat, 29 May 2010 16:24:38 +0000 Rokan http://ryanjd.com/?p=155 For all of you people that are having this problem (as I was just experiencing) check a few things before submitting a bug report to Apple:

• If you are using Interface Builder to set up your custom UITableView (without using a UITableViewController), then check that your IBOutlets are set up properly for UITableView’s properties: delegate and dataSource. If they are nil then your reloadData call will not work. Then again, your entire table won’t work, so it’s pretty clear if you haven’t set them.
• If you have subclassed UITableViewController to run your custom processes and show your custom design, then make sure you have not set the tableView property. If you have, it will override UITableViewController’s original tableView property and will ruin your application (and will most likely crash it).
• You must call reloadData on the main thread. This was my problem. If you are doing the sensible thing and downloading some data on a separate thread, and then passing it back through delegate methods or a notification center to your custom UITableViewController, make sure that you call reloadData back on the main thread. If you’re having trouble with this, use this or similar code:

[[self tableView] performSelectorOnMainThread:@selector(reloadData) withObject:nil waitUntilDone:NO];

Hopefully this cures some headaches.

This tutorial will teach you to set up a mysql table in a currently existing database, and use that mysql table to store usernames and passwords of your members. It will then show you how to verify that a user with a specific username and password exists.

This tutorial uses PHP, MySQL queries, and some HTML to achieve this.

Some important things to keep in mind are:

• The database never keeps track of an unencrypted member password.
• Members passwords must be case-sensitive, but usernames are optionally case-sensitive.

We will be storing the members’ passwords using the encryption method MD5. It is secure and easy to access in PHP.

So, first is to set up the table. I am presuming here that you already have a MySQL database set up. If you don’t, Google it.

We need to know the columns we will be using to specify our table. We need to store the members ID, the members username, and the members password. This is the bare minimum, and you can add your custom fields afterwards. A MySQL query should do the trick (you can run this from your database).

CREATE TABLE tblMembers(
id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(32) NOT NULL,
password VARCHAR(32) NOT NULL)

Feel free to insert a few test members.

The idea is this: we will store a password on the database as an MD5 hash (which is a case sensitive encryption) and we will encrypt the password being used as a login attempt to verify this password once we’ve found a matching username. If there is no matching username, then the user does not exist. If the password does not match the matched username, then the password is incorrect. If the password matches the username, then the verification is a success.
The PHP code needs to do all of the above. Below is a script that does so (but you can’t just copy and paste!).

<?

/*
 * connect to mysql
 * select database
 * etc
 */

// error codes
define('__SUCCESS', true);
define('__ERRNUM_INVALIDUSERNAME', 100);
define('__ERRNUM_INCORRECTPASSWORD', 101);

function verify_credentials( $username, $password, $password_encrypted = FALSE,  &$user = NULL)
{
        // retrieve members if their usernames match
        // lower() forces the username to lower case
        // and so the comparison is case insensitive
        $query =        mysql_query(
                                        sprintf(
                                                "SELECT username, password FROM tblMembers WHERE lower(username) = '%s';",
                                                mysql_real_escape_string(strtolower($username))
                                        )
                                );

        // if the query has no rows, it means the username does not exist
        if (mysql_num_rows($query) == 0)
        {
                // return the error code for 'invalid username'
                return __ERRNUM_INVALIDUSERNAME;
        }

        // if password is encrypted, don't encrypt again!
        // if password isn't encrypt it, encrypt it!
        $encrypted = ($password_encrypted) ? $password : md5($password);

        // loop through the found members to find a matching password
        while ($row = mysql_fetch_array($query))
        {
                // now we can access username and password of this row
                // the username is irrelevant - it MUST match or it shouldn't
                //  have been found by the query
                // so focus on the password
                if ($encrypted == $row['password'])
                {
                        // matching password!
                        // fill user if it was set
                        if (NULL != $user)
                        {
                                // give username and password to user
                                $user['username'] = $row['username'];
                                $user['password'] = $row['password'];
                        }

                        // report verification success
                        return __SUCCESS;
                }
        }

        // if we're still in this scope, it means the password wasn't found
        // so the password must have been incorrect
        return __ERRNUM_INCORRECTPASSWORD;
}

/*
 * close connection
 */

?>

You can call this function as follows:

$username = "Username";
$password = "password";
echo "Attempting login with username {$username} and password {$password}<br/>";
$result = verify_credentials($username, $password, FALSE, &$user);
if ($result == __SUCCESS)
{
        echo "Login successful. User found with credentials: {$user['username']} : {$user['password']}<br/>";
} else if ($result == __ERRNUM_INVALIDUSERNAME)
{
        echo "Login failed. User could not be found.<br/>";
} else if ($result == __ERRNUM_INCORRECTPASSWORD)
{
        echo "Login failed. Incorrect password. Remember: Passwords are case sensitive.<br/>";
} else
{
        // should never get here
        echo "Serious error occurred!";
}

Using a few cookies and a mysql INSERT query, you should be able to make a login and registration from here. I’m not going to give you all the code, that would be too easy!

Happy coding!

Creating a UITableView is easy. Mostly, UITableViews are inserted into UINavigationController’s, so we’ll do that too.

This is the initialisation code in AppDelegate.m:

- (id) init {
    if(self = [super init]) {
        window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
        UITableViewController *tableViewController = [[UITableViewController alloc] initWithStyle:UITableViewStylePlain];
        navigationController = [[UINavigationController alloc] initWithRootViewController:tableViewController];
        [tableViewController release];
    }
    return self;
}

However, since the UITableView uses delegation as a datasource and for appearances, we need to subclass UITableViewController and change the required methods.

Once we’ve replaced all instances of ‘UITableViewController’ with our custom controller (I have named mine DBTableViewController) then we can begin to alter the delegates methods. The required methods for a class that conforms to the UITableViewDataSource and the UITableViewDelegate protocols are as follows:

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section;
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView;
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath;
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath;

By responding to these methods, we can alter the appearance of the UITableView. For example, if we wanted to populate our custom UITableView class with cells labelled 1 through to 10 with 10 cells, we could use the following code:

#define kNumberOfSections 2
#define kNumberOfRows 10
 
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
    // Set up how many 'sections' (groups of rows)
    return kNumberOfSections;
}
 
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    // Set up how many rows to have in our table view
    return kNumberOfRows;
}
 
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    static NSString *CellIdentifier = @"CustomCell";
 
    /*
     All this 'dequeueReusableCellWithIdentifier' stuff does is check whether
     an instance of the same cell (with the same identifier) has been deallocated yet.
     They are autoreleased, which means there may be one available to reuse, which would save memory.
     Memory is vital on the iPhone!
    */
 
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    if (cell == nil) {
        cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:CellIdentifier] autorelease];
    }
 
    cell.textLabel.text		  = [NSString stringWithFormat:@"Row %d", indexPath.row];
    cell.detailTextLabel.text = [NSString stringWithFormat:@"Section %d", indexPath.section];
 
    return cell;
}
 
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    // Deselect this row, to conform the human interface guidelines
    [self.tableView deselectRowAtIndexPath:indexPath animated:YES];
}

The result would look like this:

Example of a list of cells using UITableView

However, if we wanted to build a UITableView from an array of items, it would be a slightly different story. For a start we would have to create a storage class for our data (an NSObject subclass) called (in our case) DBItem. DBItem looks like this:

@interface DBItem : NSObject {
	UIImage *thumbnail;
	NSString *title;
	NSString *shortDescription;
}
 
@property (nonatomic, retain) UIImage *thumbnail;
@property (nonatomic, copy)	  NSString *title;
@property (nonatomic, copy)   NSString *shortDescription;
 
- (BOOL) hasThumbnail;
 
@end
 
// DBItem.m
#import "DBItem.h"
 
@implementation DBItem
 
@synthesize thumbnail;
@synthesize title;
@synthesize shortDescription;
 
- (void) dealloc {
	[thumbnail release];
	[title release];
	[shortDescription release];
	[super dealloc];
}
 
- (id) init {
	if(self = [super init]) {
		// Any initialisation
	}
	return self;
}
 
- (BOOL) hasThumbnail {
	return (thumbnail) ? YES : NO;
}
 
@end

As you can see, all it is is a storage class. It simply contains a UIImage named ‘thumbnail’, has a name (an NSString*) that we called ‘title’ and a ‘shortDescription’ of the same type as the title. We could have just used an NSDictionary – however it is difficult to keep track of what is inside of the NSDictionary, whereas this class only ever contains these three properties. We are going to create a list of these items, and insert them into an NSMutableArray, which will be used by the UITableView as the source of its information.
I have imported our new storage class into the current script using:

#import "DBItem.h"

Also, we need to set up the NSMutableArray in our custom UITableViewController subclass.

@interface DBTableViewController : UITableViewController {
	NSMutableArray *itemArray;
}
 
@property (nonatomic, retain) NSMutableArray *itemArray;
 
@end

Don’t forget to @synthesize itemArray in the .m file!

Now we can initialise and add a list of DBItem classes to the array.

#define kNumberOfItems 6
 
- (void)dealloc {
	[itemArray release];
    [super dealloc];
}
 
- (id)initWithStyle:(UITableViewStyle)style {
    if (self = [super initWithStyle:style]) {
		// Set the title of this controller
		self.navigationItem.title = @"A List Of Items";
 
		// Initialise itemArray
		itemArray = [[NSMutableArray alloc] initWithCapacity:kNumberOfItems];
 
		// Insert a list of DBItem classes into itemArray
		for(unsigned i = 0; i < kNumberOfItems; i ++) {
			NSString *pathForImage = [NSString stringWithFormat:@"image%d.jpg", i];
			NSString *title		   = [NSString stringWithFormat:@"Thumbnail %d", i];
			NSString *description  = [NSString stringWithFormat:@"Description for item %d", i];
			UIImage  *thumbnail    = [UIImage imageNamed:pathForImage];
			DBItem   *item		   = [[DBItem alloc] init];
			[item setTitle:title];
			[item setShortDescription:description];
			[item setThumbnail:thumbnail];
			[itemArray addObject:item];
			[item release];
		}
	}
    return self;
}

All we’re doing here is defining how many items we’ve got, and then setting up strings. Title will look like ‘Thumbnail 0′ or 1, 2, 3, … etc, and description will look like ‘Description for item 0′, 1, 2, 3… etc. The images are named image0.jpg, image1.jpg, image2.jpg, image3.jpg until the end of the row count, which is kNumberOfItems. These items are then accessed by the array later on, as so:

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
	// Set up how many 'sections' (groups of rows)
	return 1;
}
 
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
	// Set up how many rows to have in our table view
    return [itemArray count];
}
 
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    static NSString *CellIdentifier = @"CustomCell";
 
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    if (cell == nil) {
        cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:CellIdentifier] autorelease];
    }
 
	DBItem *item = [itemArray objectAtIndex:[indexPath row]];
	cell.imageView.image = [item thumbnail];
	cell.textLabel.text  = [item title];
	cell.detailTextLabel.text = [item shortDescription];
 
    return cell;
}

All we’re doing here is setting the contents of the UITableViewCell to the information stored inside our DBItem class. We could easily store our array of DBItem’s inside a singleton instance, known as a data manager. This is a unique program design that is easy to upkeep and is generally nice to get into the habit of doing. There will be an article here on singleton instances eventually.
However, for now, we’ll finish UITableView’s. We have purposely left the data array as mutable so that we can edit it later. We’re going to do that now, by using the UITableView’s editing mode. This is activated as follows:

- (void)viewDidLoad {
    [super viewDidLoad];
	self.navigationItem.rightBarButtonItem = self.editButtonItem;
}

The line ‘self.navigationItem.rightBarButtonItem = self.editButtonItem’ adds a button to the right hand side of the navigation bar which contains the word ‘edit’ or ‘done’ depending on the UITableView’s editing mode. You’ve probably seen it before in, well, practically any app. This doesn’t complete editing yet! As with everything with UITableView’s, we need to set up the delegate methods:

- (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:(NSIndexPath *)indexPath {
	// return NO if we don't want this specific cell to be edited.
	if([indexPath row] == 0) {
		// this will make the first cell uneditable.
		return NO;
	} else {
		// every other cell is editable!
		return YES;
	}
}
 
- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
    if (editingStyle == UITableViewCellEditingStyleDelete) {
		// this means the user has committed a 'delete action'
		// something such as swiping it then pressing 'delete' or hitting edit
		// then tapping to select that row, and pushing delete
 
		// Need to remove it from the array
		[itemArray removeObjectAtIndex:[indexPath row]];
 
		// Animate a deletion of it from the UITableView
        [tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath] withRowAnimation:YES];
    } else if (editingStyle == UITableViewCellEditingStyleInsert) {
		// This is when the user has chosen to add a cell to the UITableView
		// However, we don't need this now!
    }
}
 
- (void) tableView:(UITableView *)tableView moveRowAtIndexPath:(NSIndexPath *)fromIndexPath toIndexPath:(NSIndexPath *)toIndexPath {
	// This method is just telling us that the user has rearranged the views
	// They have moved row 'fromIndexPath' to row 'toIndexPath'
	// So we need to change our data accordingly
 
	[itemArray exchangeObjectAtIndex:[fromIndexPath row] withObjectAtIndex:[toIndexPath row]];
}
 
- (BOOL)tableView:(UITableView *)tableView canMoveRowAtIndexPath:(NSIndexPath *)indexPath {
	// This is asking whether a certain cell should be able to be reordered or not.
	// We'll disable row 0 but enable all else
 
	if([indexPath row] > 0) return YES; else return NO;
}

After this, you should have a result much like this (except with different images):

iPhone simulator showing an editable UITableView with DBItem cells

And that’s pretty much all there is to know! To know how to save the final edited array, so that it can be used the next time the user re-opens the app, look into NSCoding and NSData saving to a file. I’ll add to this article at some point with more information about this! But until then, enjoy!

If you’ve ever wandered into the realms of game programming, you’ll probably have used a movement code much like this pseudocode:

position = position + velocity

So, in real code, it looks like this:

x += x_velocity;
y += y_velocity;

This type of movement is known as Euler movement. In this tutorial we’re going to learn about a new type of movement: Verlet.

Verlet works like this:

position = (position * 2) - position + acceleration

To see the difference, look at this example: the ball on the left uses verlet movement, and the one on the right uses euler movement.

The code for movement is here: (‘ball1′ is the ball on the left, and ‘ball2′ is the ball on the right)

var sy;
sy = ball1._y;
ball1._y = (ball1._y * 2) - ball1.yp + gravity;
ball1.yp = sy;
ball2._y += gravity;

Gravity is predefined as ’0.1′.

As you can see, the y position of ball1 is multiplied by 2 and the previous y position is taken away. This creates the difference between the current position and the previous position – so, by simply changing the position, the movement engine generates acceleration. So, if you were to set the position of a ball to (100, 100) as (x, y); then if you set the position to (101, 100) without setting the previous position – the offset is 1 on the x axis and will be used as velocity. The ball will move 1 pixel to the right each step if you keep doing this. This is essentially what the acceleration does in the formula.

By using verlet physics, you can create ragdoll physics far more easily.

Many programming languages are object-oriented. However, the method of defining an object varies from language to language. Some examples of object-oriented languages are:

• Java
• JavaScript
• C++
• and finally, PHP

Basic Class Programming in PHP

In PHP, an object is defined as this:

class myObject {
    //variables and methods go here
}

Methods are easy to add to classes. If you wanted to add a function to myObject that returns the current server time, you could do this:

class myObject{
	function getServerTime() {
		return time();
	}
}

Easy as that. Defining variables is a little bit trickier. There are many ways to define variables, but we’ll keep it simple for now and use the ‘var’ method.

class myObject {
        //this is a valid assignment
	var $variable     = 'constant value';

        //this is invalid because it is assigning to a function. This can't be done.
	var $serverTime = time();
}

To access internal variables, we have to use the $this variable. $this is a pointer that points internally, so that we can access the variables we just declared. So, we’re going to add a function to ‘myObject’ and access $variable.

class myObject {
        //this is a valid assignment
	var $variable     = 'Hello World!';
	function GetVariable() {
		//notice how there is no dollar sign $ in front of the variable
		return $this->variable; //this will return 'Hello World!'
	}
}

Notice how there is no dollar sign ($) in front of the variable we are pointing to with $this. This is also how you call methods internally.

On the last note of basic PHP classes, you will need to know how to create an instance of your class. Once you have created an instance of your class, you can use it in the same way you used ‘this’. To create an instance, use the method:

$instance = new ClassName();

This creates a new instance of the class ‘ClassName’. So, an example using everything we’ve learned:

class myClass {
	var $string = 'Hello World!';
	function ShowString() {
		echo $this->string;
	}
}
$instance = new myClass();
$instance->ShowString();

Also, it is entirely possible to create an instance of a class from a string:
class MyClass { function Exist() { echo "My class name is ".get_class($this).""; } } $classname = 'MyClass'; $instance = new $classname(); $instance->Exist(); //this will echo 'My class name is MyClass' That’s about it on a basic level! Now for some more advanced usage of classes.

Advanced Classes

class myClass {
	private $private_var = "This variable is private! You can't see this!";
	public  $public_var  = "This variable is public! Anyone can see this!";

	//note- you can also use public and private modifiers on functions
	//this is useful because internal functions should be private
	//and external functions could use more than one private function
	//it's good to make a network of public and private methods and variables
	public function PrintPrivate() {
		var_dump($this->private_var);
	}
}
$instance = new myClass();

//this line will print the contents of $private_var to the screen
//because it is being called internally using an external function of myClass
$instance->PrintPrivate();

//however, this line will print an error - private variables can't be accessed
//this is because it is being accessed externally
var_dump($instance->private_var);

When an instance of a class is created, the method (if it exists) $instance->__construct(arguments). So, with this knowledge, you should have realised that when calling:$instance = new myClass(arguments) the arguments are sent to the method __contruct inside myClass. This method is called a constructor. When an instance is deleted, the class destructor is called. The destructor is called when either every variable inside the class has been removed using the PHP function unset($variable) or at the end of the script.

class myClass {
	public $id;
	public function __construct($id) {
		$this->id = $id;
		echo "Constructed {$this->id}
";
	}
	public function __destruct() {
		echo "Destructed {$this->id}
";
	}
}

$count = 0;
$instance = Array();

//this line calls the 'construct' method and creates a new instance
$instance[$count] = new myClass($count);
$count ++;

$instance[$count] = new myClass($count); $count ++;
$instance[$count] = new myClass($count); $count ++;

This code will echo:

Constructed 0
Constructed 1
Constructed 2
Destructed 0
Destructed 1
Destructed 2

You can see that the constructor is called when the instance is created, and that the destructor is called when the script ends.

Now that we understand all of that, we can move on to…

Static Classes

So far, the classes have held variables, and have been individual instances. However, if, for example, you wanted a variable that had a set value and applied to all instances of the class, how would you do it? The answer is static variables:

class myClass {

 //the use of 'static' can be before or after 'public'
 //and it makes the variable global across the class
 static public $variable = 'Hello World!<br/>';

 static public function ShowText() {
 //for static variables, we use self:: instead of $this->
 echo self::$variable;
 }

 //notice that there is no constructor

}

//there is no need to construct a static class!
myClass::ShowText();
//this will output 'Hello World!'

//however, it is possible to create instances and use static at the same time
$class = Array();
$class[0] = new myClass();

//this is an invalid static function caller:
//$class[0]::ShowText();
//this will result in a parse error!

//this will work:
$class[0]->ShowText();
//it works because the function can be accessed
//statically and non-statically

$class[1] = new myClass();

//let's try something!
var_dump($class[0]->variable); echo "<br/>";
var_dump($class[1]->variable); echo "<br/>";
//these will both echo NULL because using ->
//as a pointer is incorrect!

$class[0]->variable = 'I\'m class one!';
$class[1]->variable = 'I\'m class two!';

$class[0]->ShowText();
$class[1]->ShowText();
//these will both echo 'Hello World!' because
//using -> as an operator will only change
//the class instance value of $variable
//which previously didn't exist.

//let's try changing it statically and echoing again!
myClass::$variable = 'This text has been changed!<br/>';
$class[0]->ShowText();
$class[1]->ShowText();
//these will both echo 'This text has been changed!' because
//the variable has statically been changed
//and this applies to all instances of the class

Here’s the code for the function ‘Troubleshoot()’ inside Database:

static public function Troubleshoot() {
		//make a list of all tables in the database
		$TABLES = Array();
		$table_list = self::Query("show tables");
		while($row = self::Fetch($table_list)) {
			array_push( $TABLES, $row['Tables_in_database'] );
		}

		//check for tables that don't exist in the mysql database and create
		foreach(self::$STRUCTURE as $key => $index) {
			if( !in_array( $key, $TABLES ) ) {
				echo "'{$key}' doesn't exist! Creating... ";
				if($create_query = Database::GetCreateQuery($key)) {
					Database::Query($create_query);
					echo "Table created!";
				} else {
					echo "Failed to create table.";
				}
			}
		}
		echo "
";
		//repair currently existing tables
		foreach($TABLES as $name) {
			if( array_key_exists($name, self::$STRUCTURE) ) {
				echo "Troubleshooting table '{$name}' : {
";
				$table_structure_query = self::Query( "describe {$name}" );
				$i = 0; while($table_structure = self::Fetch($table_structure_query)) {
					$table_row = self::$STRUCTURE[$name][$i];

					//Convert some of the table schemas to the easier to use ones stored in self::$STRUCTURE
					$table_structure['Null'] = ( ($table_structure['Null'] == 'NO') ? 'not null' : 'null' );
					$table_structure['Key']  = ( ($table_structure['Key'] == 'PRI') ? "PRIMARY KEY({$table_structure['Field']})" : '' );

					//check the table schema matches
					if(
					$table_structure['Field'] == $table_row['field'] &&
					$table_structure['Type']  == $table_row['type'] &&
					$table_structure['Null']  == $table_row['null'] &&
					$table_structure['Key']   == $table_row['primary key'] &&
					$table_structure['Extra'] == $table_row['extra']
					) {
						echo "
The table '{$table_structure['Field']}' is intact and built properly.

";
					} else {
						echo "
The row '{$table_structure['Field']}' is corrupted. Attempting to repair...";
						if(self::RepairTable($name)) echo "Repaired!";
						echo "

";
					}

					$i ++;
				}
				echo "}

";
			}
		}
	}

I’ll edit this all another day to make it more comprehensible. Right now, though, it’s 3am and I’m too tired to concentrate.

public static $STRUCTURE = Array(
	'members' => Array(
		Array(
			'field' => 'id',
			'type' => 'int(11)',
			'null' => 'not null',
			'extra' => 'auto_increment',
			'primary key' => ', PRIMARY KEY(id)',
			'suffix' => ','
		),
		Array(
			'field' => 'member_name',
			'type' => 'varchar(32)',
			'null' => 'not null',
			'suffix' => ','
		),
		Array(
			'field' => 'member_pass_hash',
			'type' => 'varchar(32)',
			'null' => 'not null'
		)
	)
);

This may look complicated and overkill – however, this could easily be loaded from an ini file, another php file, and updated from the mysql database itself (with the latter being the easiest option). However, updating the structure from the database can obviously only be done when the database is functioning perfectly. This way, the array self::$STRUCTURE can be used to repair the database and to create queries. For example, the query:
CREATE TABLE members( id INT NOT NULL AUTO_INCREMENT , PRIMARY KEY(id) );

This query could easily be generated by using the following structure:

private static $STRUCTURE = Array(
	'members' => Array(
		Array(
			'field' => 'id',
			'type' => 'int(11)',
			'null' => 'not null',
			'extra' => 'auto_increment',
			'primary key' => ', PRIMARY KEY(id)'
		)
	)
);

A function could be devised to transform this table structure into a mysql query. Something like this:

static public function GetCreateQuery($table) {
	$structure = self::GetTableStructure($table);
	if($structure != 0) {
		$query = "CREATE TABLE " . $table . "( ";
		foreach($structure as $index) {
			$query .= implode(' ', $index) . " ";
		}
		$query .= ");";
		return $query;
	} else {
		return false;
	}
}

This function should return a valid MySql query if set up properly. If you run the query in your MySql panel, it creates the correct table with primary key and extra values. It should be easy from here to design a system that can troubleshoot its own MySql tables. For example, to repair a table, a query like this could be used (but obviously altered):
CREATE TABLE new_members_table(id int(11) not null auto_increment);
INSERT INTO new_members_table SELECT * FROM old_members_table;
DROP TABLE old_members_table;
RENAME TABLE new_members_table TO old_members_table;

Notice that the structure of the table created is the same as was created by our ‘GetCreateQuery’ function, and was structured by the self::$STRUCTURE['members'] array.

Using this could improve your PHP blogging system, forum software, commenting software.. any kind of web software which uses PHP and MySql databases – so there is no limit to its use!