I believe that God created the world, and that those who are chosen by him should obey him to the best of their abilities.  Despite these aspirations, I'm a terrible sinner.

Nonetheless, at least I've got goals to aspire to, right?  Sure, there are quite a few that most people don't agree with, especially the ones that prohibit actions that non-Christians (and even many self-proclaimed Christians) don't want to call evil.

Still, most people are on board with the second-greatest commandment – in fact, according to popular culture, that is in fact the main point of Jesus' coming to Earth!

37 Jesus said to him, "'You shall love the LORD your God with all your heart, with all your soul, and with all your mind.'

38 This is the first and great commandment.

39 And the second is like it: 'You shall love your neighbor as yourself.'

40 On these two commandments hang all the Law and the Prophets."

Matthew 22:37-40 (NKJV)

(And for those paying attention, yes, I consider Penny Arcade to be an arbiter of popular culture.)

But if I'm not engaging in weekly gay-hunts, what IS my Christianity doing for me?  Well, among the many other instructions for living life that God passed down to us, it seems that he really does care about Christians being an improvement for the quality-of-life of the people around us:

"Let me tell you why you are here. You're here to be salt-seasoning that brings out the God-flavors of this earth. If you lose your saltiness, how will people taste godliness? You've lost your usefulness and will end up in the garbage." Matthew 5:13 (MSG)

Seriously, what is this post even about

All right, so Christians aren't supposed to be assholes.  Most people sort of assume that already, even given plenty of implicit counter-arguments via the actions of Christians they know.

However, I've noticed a high correlation between driving a vehicle on the road and anger.  While driving as a passenger, I've noticed that it is extremely common for a driver to express anger at

• The drivers sharing the road with him
• Shitty things that happen while driving (inconvenient red lights, poor road signs, etc)

The former is by far the most common – the other vehicles on the road have a tendency to cut you off, slow you down, fail to announce where they are going, and generally just act like jerks.

Why does that burn people up so much?

If I accidentally bump my shopping cart into someone else at the grocery store, I'll quickly apologize – and the odds are that they'll say something to the effect of "ah, don't worry" or give an understanding smile, or at worst give a small huff and push on in annoyance.

If I turn left on a street and someone in oncoming traffic has to slow down to avoid me safely, I don't usually get a chance to hear their response.  I've driven with enough people to imagine it, though – when you see someone doing something stupid or unnecessary in a way that inconveniences you, you generally feel a quick flash of anger toward them, and may say something to that effect at their expense.

Maybe it's because you just see vehicles – you're not dealing with humans, you're dealing with 4 wheels and a bumper sticker pushing [political party you hate]!  Most people are polite enough to be diplomatic in the face of being inconvenienced by another human face, but if a hunk of metal cuts you off, you feel real rage at the theoretical person inside of it!

I'm glad I'm smarter than that!

Oh wait, no, I get mad exactly like that, all the time.  Despite the Bible hammering in the fact that God expects you to be working on this self-control thing, I've raged at other drivers about 100% more than I should have.  What am I supposed to do, turn every driving excursion into a painful turn-the-other-cheek exercise?

Well, that has kind of happened – but not until after I started adopted a proactive stance towards driving smart.

My life was changed (no, really!) when I read this site written by an engineer on the internet.  I'd recommend reading it over, but here's the basic premise:

• Busy roads (especially big ones like highways) get inefficient to travel on quite a bit
• It turns out that if you drive in a certain way, you can make highway driving a lot more efficient… not for you, but for all the people behind you, too

So how does a motivated engineer make the world better?  It turns out, you can improve the quality-of-life of those around you by simply leaving a big gap between you and the vehicle in front of you.

I don't want to belabor all of the points he makes (seriously, you should read his site), but the general idea is

• If you never hit your brakes, the people behind you never have to hit their brakes, which lets everyone avoid the burst-forward-then-come-to-nearly-a-complete-stop situation that happens way too often on busy roads
• It's easy for people to merge in in front of you, which lets the lanes next to you avoid the someone-driving-really-slow-trying-to-merge-lanes situation

Is that really how you drive like a Christian?

So you're leaving a carefully-engineered gap between you and the traffic in front of you.  Traffic behind you is demonstrably better because of it.  What's the big deal?

Well, it turns out that this habit is not natural at all.  At least not to me.  When did I turn into a competitive driver looking to beat everyone else to my exit?  I'm not sure.  Maybe it was the day I got my drivers license.  Maybe it was the day I was born with two working testicles.  I haven't been able to pin it down.

They just… keep… merging!

People will merge in front of you.  And man, no matter how zen I've been feeling about driving lately, my first instinct is STILL "gotta close the gap so the rest of the horde doesn't jump in in front of me!"

Calm yourself with these facts: each car who merges in front of you (potentially forcing you to let up on the accelerator in order to maintain good distance between you and the car ahead) adds… maybe 5 seconds to your trip.  Sure, there's a slim chance that those 5 seconds could cause you to miss a light somewhere, but aren't those low odds worth improving the driving situation for all those around you and behind you?

Don't forget: the easier it is for people to merge into your lane, the smoother traffic will be for all of the people behind you!

Not dying is good, too

So yeah, this falls by the wayside whenever people are in a hurry, but it turns out that the more space you leave between you and the vehicle in front of you, the safer you are.

I'm struggling not to write a 500-word rant on this topic alone.  Two seconds to respond to sudden developments ahead of you makes a massive difference compared to one second… and protip: you've been counting seconds too fast.  Giving yourself a larger margin of error turns "accidents" into much safer near-misses.

But keeping your car and skull dent-free are just happy side effects that can happen when you decide to try to apply the biblical principle of making-life-better-for-others to driving.

Resist the power of John Gabriel's Greater Internet Fuckwad Theory – start training yourself to be a blessing to the anonymized people on the road around you!

Here's an example of how you might use the prepared query functionality in PHP (straight from the docs!):

if ($stmt = $mysqli->prepare("SELECT District FROM City WHERE Name=?"))
{
	$stmt->bind_param("s", $city);
	$stmt->execute();
 
	$stmt->bind_result($district);
	$stmt->fetch();
 
	printf("%s is in district %s\n", $city, $district);
 
	$stmt->close();
}

It's a pretty reasonable-looking way of building a query. Here's how you would have to build that query normally:

$mysqli->query("SELECT District FROM City WHERE Name='" 
	. $mysqli->real_escape_string($city) . "'");

Once you want to start using a lot of random static strings in your query, it can get pretty messy – having to concatenate all of those strings together, calling that escape function everywhere – using the bind_param function makes things a lot more readable.

IF YOU'RE AN IDIOT!

No wait, hear me out, I didn't mean it like that – what I meant to say is, the prepared query syntax is probably doing more work than you expect it to.

See, prepared statements are actually a SQL thing, not something that the PHP devs added to the mysqli wrapper just because they thought it would be cool. You can use prepared statements from the MySQL command line, too:

PREPARE my_statement FROM 'SELECT District FROM City WHERE Name=?';
SET @city := 'Amersfoort';
EXECUTE my_statement USING @city;
DEALLOCATE PREPARE my_statement;

mysqli::prepare is just giving you access to this nifty feature, which is fine and dandy. However, you may have noticed something -

That's a lot of queries to run, just to run a single SELECT query!

Now, if you're going to be running a ton of INSERT or UPDATE queries, and you just want to swap the variables out each time, you're fine – letting MySQL hang on to the meat of a query you're going to be running a hundred times is downright reasonable.

BUT – if all you're doing is running a half dozen queries while you're building a web page to display to the user, the only thing you're doing is increasing the number of times you have to contact the server.

How many superfluous database-contacts will there be? As far as I can tell, you'll be contacting the server three times more than you need to:

• Once to prepare the statement
• Once to send the parameters to the server and get the results back
• Once to deallocate the statement

(I haven't looked at the source code, but I'm guessing that commenter Angus M is correct in his assessment that binding a parameter does not cause communication with the database.)

If your database server is running on the same host as your web server, the cost of contacting the database is probably pretty low. Still, after years of developing thinnish-desktop clients, my instinct is to avoid that overhead wherever possible.

Stuck between a rock and an inefficient place

I imagine that, among the people who took those last few paragraphs seriously, there are two camps – the coders who will say "well, whatever" and keep writing queries using the prepare syntax because it's more convenient and easier to read (which is an argument I can understand), and the efficiency advocates who will give a tortured sigh and go back to writing queries with lots of awkward concatenation, in order to avoid overhead.

Or you could write/copy some simple query-building tools that do the stuff that you originally thought mysqli::prepare was doing!

Here's a function I threw together last night, which I imagine would suit the needs of many developers using PHP/MySQL:

<?php
 
function GetQueryWithData()
{
	$Query = "";
	$ParameterNumber = 0;
 
	if (func_num_args() && $Query = func_get_arg($ParameterNumber++))
	{
		while ($ParameterNumber < func_num_args())
		{
			$NextParameter = func_get_arg($ParameterNumber++);
			$PlaceToInsertParameter = strpos($Query, '?');
			if ($PlaceToInsertParameter !== false)
			{
				$QuerySafeString = '';
 
				if (is_bool($NextParameter))
				{
					$QuerySafeString = $NextParameter ? 'TRUE' : 'FALSE';
				}
				else if (is_float($NextParameter) || is_int($NextParameter))
				{
					$QuerySafeString = $NextParameter;
				}
				else if (is_null($NextParameter))
				{
					$QuerySafeString = 'NULL';
				}
				else
				{
					$QuerySafeString = "'" . mysql_escape_string($NextParameter) . "'";
				}
 
				$Query = substr_replace($Query, $QuerySafeString, $PlaceToInsertParameter, 1);
			}
		}
	}
 
 
	return $Query;
}
 
print GetQueryWithData("SELECT * FROM `ass` WHERE `butt` = ? AND `cheek_id` = ? AND ? "
	. "AND `nullable_field` IS ? ", 
	"lol 'WUT'", 13, true, null) . "\n";
/* SELECT * FROM `ass` WHERE `butt` = 'lol \'WUT\'' AND `cheek_id` = 13 AND TRUE 
	AND `nullable_field` IS NULL */
 
print GetQueryWithData('UPDATE `some_table` SET `some_column` = ?, `some_other_column` = ?, '
	. '`some_id` = ? WHERE `yourface` = ?', '20', 
	21, 69, 'sucks') . "\n";
/* UPDATE `some_table` SET `some_column` = '20', `some_other_column` = 21, 
	`some_id` = 69 WHERE `yourface` = 'sucks' */
?>

The above function is a simple way to build a query with any number of parameters. Strings will be escaped, numbers will not be quoted, and the function never contacts the database server.

Using this function, you can redux the query from the original example while only contacting the database once:

$mysqli->query(GetQueryWithData("SELECT District FROM City WHERE Name=?", $city));

If you don't want to use that function, or roll your own query-builder, you can keep using mysqli's wrapper for prepared statements – just know that it was made for a different purpose, and it comes with a bit more cost.

Edit: PDO!

After some discussion with ss23 in #mysql, I thought I'd better add some comments about the PDO class.

On the surface (and according to much of the documentation), it appears to be a more generic (not just MySQL-specific) database wrapper with similar prepared-statement support. However, it turns out that by default, it only fakes prepared statements!

So, it is possible to use PDO to write queries using a bind-parameter syntax that can make your code a lot easier to read, and simultaneously avoid contacting the database too often. However, if that is how you decide to roll, I would recommend turning on fake-prepared-statements mode explicitly, just in case that default gets changed in the future:

$pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, 1);

If universities really cared about educating their students, they would take an audit once a year (at least) to take scope of the current programming world.

They would look at the currently available development platforms, and identify the ones that were well-established and provided the best introduction to tools that could solve real-world problems that real-world application developers were working on.

Then they would go out and hire professionals with real experience in these languages (!) to train the students in using these tools without sucking.

This would comprise most of the third and fourth year studies for computer scientists (or whatever bachelor's degree that would represent "practical programming").

But wait, what about the first two years? Oh, well that would be spent teaching developers to work on projects in a way that would make them (the software projects) not suck.

Everyone initially sucks at writing software that coders (even themselves) will have to maintain. It generally takes at least a year or two to work the worst of these symptoms out of your system.

If universities focused on the practical, they would work on beating that stupidity out of every student who wanted to write software.

If universities were practical, while simultaneously forward-thinking, they would smack the stupidity out of students while *also* training them on systems that real companies were using to solve current problems.

Based on my limited education, I note that universities spend most of their efforts on the completely irrelevant (general electives, ho!) and mathematical work that is only useful to coders who are already well-educated.

But don't take my opinion too seriously – I am a college dropout, after all.

Perhaps I should be consoled by the fact that the reason I'm looking at these prior works now isn't because they broke in front of a customer. This time, at least.

However, this is what I've used in most scripts I've thrown together in the last few years – I hate having to throw a mysql_error call after every query, y'know?

<?php
 
define('CLIENT_LONG_PASSWORD', 1);
 
class MySQLWrapper
{
	var $server_port	=		'localhost:3306';
	var $database 		=		'whatever';
	var $username 		=		'a username';
	var $password 		=		'a password';
	var $force_long_password = false;
	var $db_object;
 
	function __construct($server_port = "", $database = "", $username = "", $password = "", $force_long_password = false)
	{
		$this->server_port = $server_port;
		$this->database = $database;
		$this->username = $username;
		$this->password = $password;
		$this->force_long_password = $force_long_password;
 
		if ($this->server_port != "")
		{
			$this->Connect();
		}
	}
 
	function Connect()
	{
		if (isset($this->db_object))
		{
			if (!mysql_ping($this->db_object))
			{
				unset($this->db_object);
				$this->Connect();
			}
		}
		else
		{
			$db_object = mysql_connect($this->server_port, $this->username, $this->password, false, $this->force_long_password ? CLIENT_LONG_PASSWORD : 0);
			if ($this->database != '' && !mysql_select_db($this->database))
			{
				$result = mysql_error();
				print "Select database failed for $this->database: $result\n";
			}
		}
	}
 
	function Disconnect()
	{
		$return = true;
 
		if (isset($this->db_object))
		{
			$return = mysql_close($this->db_object);
			unset($this->db_object);
		}
 
		return $return;
	}
 
	function Execute($query)
	{
		$this->Connect();
		$result = mysql_query($query);
		if (!$result)
		{
			$result = mysql_error();
			print "Query failed: $result\n";
			print "Teh query itself: $query\n";
		}
		return $result;
	}
}
 
?>

You may find this slightly better than using PHP's MySQL functions straight out of the box. Or not. Who can say?

I don't even know why I felt like writing this.

This script will keep a certain percentage of the tables in your MySQL database locked. It will lock the first N% of your database, and then move forward one table at a time, locking the next table in line and releasing the lock on the one at the end of the tail.

Why would someone use this script? For benchmarking some completely unrealistic scenario? To decrease database efficiency for no good reason? Who can say.

Note: you'll get to lock/release tables a lot more quickly if you run this script locally.

<?php
 
$percentage_of_database_to_lock = .25;
 
require('./shared/mysql.php');
 
$mysql = new MySQLWrapper();
$mysql->server_port = 'host:3306';
$mysql->database = 'some_db';
$mysql->username = 'some_user';
$mysql->password = 'some_pass';
 
$res = $mysql->Execute('SHOW TABLES');
 
$tables = array();
 
if ($res)
{
	while ($row = mysql_fetch_array($res))
	{
		$tables[] = $row[0];
	}
}
 
$tables_to_lock = floor($percentage_of_database_to_lock * count($tables));
 
if ($tables_to_lock > 1)
{
	$cycles = 0;
	$start_at = 0;
 
	while (true)
	{
		$query = 'LOCK TABLE';
		$tables_so_far = 0;
 
		while ($tables_so_far < $tables_to_lock)
		{
			$next_index = $start_at + $tables_so_far;
			if($next_index >= count($tables))
			{
				$next_index = $next_index - count($tables);
			}
 
			$query .= '`' . $tables[$next_index] . '` WRITE, ';
			$tables_so_far++;
		}
 
		$query = substr($query, 0, strlen($query) - 2);
 
		$mysql->Execute($query);
 
		$start_at++;
 
		if ($start_at > count($tables))
		{
			$start_at = 0;
			print "Cycle " . ++$cycles . "\n";
		}
	}
}
 
?>

Dependencies: MySQLWrapper

I decided to open up by looking for traditional profanities – a commonly-accepted method of gauging the state of a project (see: profanities in the Linux kernel, graphed over time and a quick look at the Win2k source).

Below, I provide a list of my findings, with a few examples. Enjoy a look at the source code of a functioning product with many users!

Disclaimer: if any of the words that you are about to read will offend you, then don't read them.

The classics

I started off by looking for looking for the current English classics:

Fuck: 6 times.
Example:

// If they had any unsaved changes, they're pretty much fucked, because
// this customer has apparently been modified by another screen.

Shit: 10

// For now, I believe that all the data is updated on the fly, so saving first is not
// necessary, but maybe we should just for shits and giggles

Crap: 22
The expletive for the more vocabulary-sensitive programmer!

//!!! It was late, we were tired, so I hacked this crap together !!!

// What the crap does this button do? - I disabled it because I think that this button
// is misleading and confusing

Hell: 1

// If it wasn't any of the valid options, then get the hell out

Insults

It's usually another programmer's fault.

Stupid: 75
The code is stupid, the users are stupid, other developers are stupid. According to the comments, at least.

// Clear out year if it is a stupid number

// Here we tell the user they are stupid when they do stupid things
// If the user forgets to specify a table, gently remind them that it's a good idea,
// then return

// When you minimize, it tells you you're size 0 now.  That seems stupid, ignore it

// Die, stupid message boxes

TRACE("Stupid quickbooks.\n");

IQBBasePtr stupid = response->GetDetail();
TRACE("Response Type: %d\n", (int)stupid->Type->GetValue());
InterpretResponse(stupid);

// Thigs are different (stupid) without this flag.  I don't currently support its omission

Dumb: 17

// There was some seriously wacky code here earlier including a really dumb memory leak.
// I tested my changes and they seem to work fine, nevertheless, I wasn't able
// to fully understand what this code was attempting to do so I may have missed
// some obscure feature.

Retarded: 4

// Because CStrings are retarded and don't do well with binary data, we have to copy the
// data in to the query in a rather inconvenient manner.

Idiot: 2

// Else politely inform the user that they are an idiot

Hack: 6

// Look at the first part of the label to find the operation (this is a sort of
// dirty hack so that) we don't have to change the database.

Incredulity

Really?

Why: 84
The only word with a higher count than "stupid" – there is always more for a programmer to learn. Or speculate on. Or rage at.

//!!! For some reason ODBC crashes at this point if you've already done a query !!!
//!!! I can't really figure out why !!!

// Not sure why we would want to do bitwise operations...

// WHy doesn't this exist?

// I don't see why we'd do this

// CRH asks: Why do we use Format() instead of "="? Can't we assume that it's slower?
// JDD Answers: what Formats?  What are you talking about?  You crazy, Charles!

// Removed 2006.02.17 - This makes it so that negative balances show up positive.
// I am not sure sure why it was ever here.

// This doesn't seem to work.  I'm not sure why

wtf: 25
Often heard expressed verbally by developers reading code.

catch (...)
{
	TRACE("Seriously, wtf\n");
	// sic vita est
}

// Sort the incoming files alphabetically (windows sometimes reverses the order (wtf?)

Random

Ridiculous: 2
When three syllables just isn't enough.

// Make the quantity not have ridiculous decimal places

Pants: 3
That's right, and all 3 times inside of a static string, too!

strPCProductCode = GetInitSetting(__MASTERWND, "session", "productcode", "pants");

That fourth argument is the default value, returned if there is no existing setting with that name. So… yeah.

lol: 3

// lol xor
if ((bPaid || bUnpaid) && !(bPaid && bUnpaid))

lulz: 1

// Half implemented, lulz

A few other gems

Ebonics?

// If shift was already depressed, fo' real, don't screw that up

Obvious mental deterioration:

// A grape typed this line in:
//9

And… uh… this was at the bottom of a header file…

// Standardized code makes him happy!
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;;        ;;;;;;;;        ;;
;;       ;;      ;;       ;;
;;      ;; ;;  ;; ;;      ;;
;;      ;;        ;;      ;;
;;      ;;    ;   ;;      ;;
;;      ;;        ;;      ;;
;;      ;; ;;;;;; ;;      ;;
;;       ;;  ;;  ;;       ;;
;;        ;;;;;;;;        ;;
;;                        ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;

// Non-Standardized code makes him sad!
// And keeps him up all night, screaming
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                        ;;
;;        ;;;;;;;;        ;;
;;       ;;;    ;;;       ;;
;;      ;; /*\/*\ ;;      ;;
;;      ;; \_/\_/ ;;      ;;
;;      ;;   ^^   ;;      ;;
;;      ;; /****\ ;;      ;;
;;      ;; \****/ ;;      ;;
;;       ;;      ;;       ;;
;;        ;;;;;;;;        ;;
;;                        ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;

8-|

So, yeah…

Found any entertaining metadata in code?  Link me!

In some issue of Maxim (November 2005?) there was an article featuring absurd sandwich-based foods.  So ridiculous were these edibles that some fraternity brothers of mine decided that the consumption of one such sandwich would make a fitting end-of-semester celebration.

I was unable to find the original article online, but found the ingredients here.  I post them here for posterity.

The Dirty Mother

"Use two slices of buttery Texas toast as bookends, and slap together a sausage patty, hash browns, and three generous chops of ham, separating each layer with a slice of cheddar cheese. Throw two fried eggs in the mix, and comfort them with four strips of crispy bacon. A splash of ketchup or Worcestershire sauce is your choice, but tons of S&P is mandatory."

We would usually go to IHOP, order the ingredients individually, and assemble the sandwiches ourselves.  The braver souls in the group would purchase fries as a side dish.

These memories are making me hungry.

No?

Well, how about something like CHECK or REPAIR table, then?

If you ever find yourself in the rare situation where you need to run the same query across every table in a database, this procedure might make your life easier:

DELIMITER $$
CREATE PROCEDURE `p_run_for_each_table`(IN strDatabase TEXT, IN strOperation TEXT)
    DETERMINISTIC
BEGIN
	DECLARE strQuery TEXT;
	DECLARE strTable VARCHAR(255);
	DECLARE bDone INT DEFAULT 0;
	DECLARE TableCursor CURSOR FOR
		SELECT `TABLE_NAME`
		FROM `information_schema`.`TABLES`
		WHERE `TABLE_SCHEMA` = strDatabase AND TABLE_TYPE = 'BASE TABLE';
	DECLARE CONTINUE HANDLER FOR NOT FOUND SET bDone = 1;
 
	OPEN TableCursor;
 
	REPEAT
		FETCH TableCursor INTO strTable;
 
		SET @QueryThatWasPassedIn := REPLACE(
			REPLACE(strOperation, '{?database}', strDatabase)
			, '{?table}', strTable);
 
		PREPARE Statement FROM @QueryThatWasPassedIn;
		EXECUTE Statement;
	UNTIL bDone END REPEAT;
 
	CLOSE TableCursor;
	DEALLOCATE PREPARE Statement;
END$$
DELIMITER ;

Useage

The procedure takes two parameters. The first one is the name of the database whose tables you want to run the query for.

The second is the query you would like to run. The strings "{?database}" and "{?table}" will be replaced with the database and table names.

CALL p_run_for_each_table('databasename', 'SELECT * FROM {?database}.{?table}');

What queries you can run

You should be able to use any queries that can be run in a prepared statement – you can find the list about two-thirds of the way down this page.

As of MySQL 5.1, you can run these queries: "ALTER TABLE, CALL, COMMIT, CREATE INDEX, CREATE TABLE, DELETE, DO, DROP INDEX, DROP TABLE, INSERT, RENAME TABLE, REPLACE, SELECT, SET, UPDATE, and most SHOW statements."

One particular error that I've seen time and time again (even from people who have been writing queries for a while) can occur when summarizing data from multiple tables that have a one-to-many relationship.

…In other words, it could occur in queries written for most database-driven software.

Solution: fix the problem by writing about it!

I wrote a page documenting the cause of the logical error, doing my best to warn people against letting it slip into their own code.

I attempted to write it so it would be easy to read, possibly even entertaining (a lofty goal for a manual on writing database queries, perhaps) – there is some colorful language and plenty of juvenile humor mixed with the tech-speak.

The doc itself is part of the wiki of the company where I work. I don't write a ton of documentation for our developers or customers (certainly not as much as I should), but whenever I do, I get this awesome feeling of usefulness. Oh, and pride. Sometimes, I feel so proud, that I feel compelled to link other people (who have no relationship to my company) to what I wrote! Ridiculous, I know.

Remember: if you write queries, it is your responsibility to guarantee that they return true and accurate data!