mysql.c

适合于Unix/Linux下的一个持久数据库连接池

	MYSQL_TYPE_DATETIME,
	// "NUMERIC"
	MYSQL_TYPE_DECIMAL,
	// "DECIMAL"
	MYSQL_TYPE_DECIMAL,
	// "SMALLDATETIME"
	MYSQL_TYPE_DATETIME,
	// "SMALLMONEY"
	MYSQL_TYPE_DECIMAL,
	// "IMAGE"
	MYSQL_TYPE_BLOB,
	// "BINARY"
	MYSQL_TYPE_BLOB,
	// "BIT"
	MYSQL_TYPE_TINY,
	// "REAL"
	MYSQL_TYPE_DECIMAL,
	// "FLOAT"
	MYSQL_TYPE_FLOAT,
	// "TEXT"
	MYSQL_TYPE_STRING,
	// "VARCHAR"
	MYSQL_TYPE_VAR_STRING,
	// "VARBINARY"
	MYSQL_TYPE_BLOB,
	// "LONGCHAR"
	MYSQL_TYPE_BLOB,
	// "LONGBINARY"
	MYSQL_TYPE_BLOB,
	// "LONG"
	MYSQL_TYPE_BLOB,
	// "ILLEGAL"
	MYSQL_TYPE_NULL,
	// "SENSITIVITY"
	MYSQL_TYPE_STRING,
	// "BOUNDARY"
	MYSQL_TYPE_STRING,
	// "VOID"
	MYSQL_TYPE_NULL,
	// "USHORT"
	MYSQL_TYPE_SHORT,
	// added by lago
	// "UNDEFINED"
	MYSQL_TYPE_NULL,
	// "DOUBLE"
	MYSQL_TYPE_DOUBLE,
	// "DATE"
	MYSQL_TYPE_DATETIME,
	// "TIME"
	MYSQL_TYPE_DATETIME,
	// "TIMESTAMP"
	MYSQL_TYPE_TIMESTAMP,
	// added by msql
	// "UINT"
	MYSQL_TYPE_LONG,
	// "LASTREAL"
	MYSQL_TYPE_DECIMAL,
	// added by mysql
	// "STRING"
	MYSQL_TYPE_STRING,
	// "VARSTRING"
	MYSQL_TYPE_VAR_STRING,
	// "LONGLONG"
	MYSQL_TYPE_LONGLONG,
	// "MEDIUMINT"
	MYSQL_TYPE_INT24,
	// "YEAR"
	MYSQL_TYPE_YEAR,
	// "NEWDATE"
	MYSQL_TYPE_NEWDATE,
	// "NULL"
	MYSQL_TYPE_NULL,
	// "ENUM"
	MYSQL_TYPE_ENUM,
	// "SET"
	MYSQL_TYPE_SET,
	// "TINYBLOB"
	MYSQL_TYPE_TINY_BLOB,
	// "MEDIUMBLOB"
	MYSQL_TYPE_MEDIUM_BLOB,
	// "LONGBLOB"
	MYSQL_TYPE_LONG_BLOB,
	// "BLOB"
	MYSQL_TYPE_BLOB,
	// added by oracle
	// "VARCHAR2"
	MYSQL_TYPE_VAR_STRING,
	// "NUMBER"
	MYSQL_TYPE_DECIMAL,
	// "ROWID"
	MYSQL_TYPE_LONGLONG,
	// "RAW"
	MYSQL_TYPE_BLOB,
	// "LONG_RAW"
	MYSQL_TYPE_BLOB,
	// "MLSLABEL"
	MYSQL_TYPE_BLOB,
	// "CLOB"
	MYSQL_TYPE_BLOB,
	// "BFILE"
	MYSQL_TYPE_BLOB,
	// added by odbc
	// "BIGINT"
	MYSQL_TYPE_LONGLONG,
	// "INTEGER"
	MYSQL_TYPE_LONG,
	// "LONGVARBINARY"
	MYSQL_TYPE_BLOB,
	// "LONGVARCHAR"
	MYSQL_TYPE_BLOB,
	// added by db2
	// "GRAPHIC"
	MYSQL_TYPE_BLOB,
	// "VARGRAPHIC"
	MYSQL_TYPE_BLOB,
	// "LONGVARGRAPHIC"
	MYSQL_TYPE_BLOB,
	// "DBCLOB"
	MYSQL_TYPE_BLOB,
	// "DATALINK"
	MYSQL_TYPE_STRING,
	// "USER_DEFINED_TYPE"
	MYSQL_TYPE_STRING,
	// "SHORT_DATATYPE"
	MYSQL_TYPE_SHORT,
	// "TINY_DATATYPE"
	MYSQL_TYPE_TINY,
	// added by firebird
	// "D_FLOAT"
	MYSQL_TYPE_DOUBLE,
	// "ARRAY"
	MYSQL_TYPE_SET,
	// "QUAD"
	MYSQL_TYPE_SET,
	// "INT64"
	MYSQL_TYPE_LONGLONG,
	// "DOUBLE PRECISION"
	MYSQL_TYPE_DOUBLE,
	// "int2"
	MYSQL_TYPE_SHORT,
	// "_int2"
	MYSQL_TYPE_LONG ,
	// "int4"
	MYSQL_TYPE_LONG,
	// "_int4"
	MYSQL_TYPE_LONG,
	// int8
	MYSQL_TYPE_LONG,
	// _int8
	MYSQL_TYPE_LONG,
	// oid
	MYSQL_TYPE_LONG,
	// _oid
	MYSQL_TYPE_LONG,
	// tid
	MYSQL_TYPE_LONG,
	// _tid
	MYSQL_TYPE_LONG,
	// xid
	MYSQL_TYPE_LONG,
	// _xid
	MYSQL_TYPE_LONG,
	// cid
	MYSQL_TYPE_LONG,
	// _cid
	MYSQL_TYPE_LONG,
	// float4
	MYSQL_TYPE_FLOAT,
	// _float4
	MYSQL_TYPE_FLOAT,
	// float8
	MYSQL_TYPE_DOUBLE,
	// _float8
	MYSQL_TYPE_DOUBLE
};

enum enum_field_types map_col_type(const char *columntype) {
	debugFunction();
	for (int index=0; datatypestring[index]; index++) {
		if (!charstring::compare(datatypestring[index],columntype)) {
			return mysqltypemap[index];
		}
	}
	return MYSQL_TYPE_NULL;
}

int mysql_execute(MYSQL_STMT *stmt) {
	debugFunction();

	stmt->result->previousrow=0;
	stmt->result->currentrow=0;
	stmt->result->currentfield=0;
	sqlrcursor	*sqlrcur=stmt->result->sqlrcur;

	int	retval=!sqlrcur->executeQuery();

	delete[] stmt->result->fields;

	int	colcount=sqlrcur->colCount();
	if (colcount) {

		MYSQL_FIELD	*fields=new MYSQL_FIELD[colcount];
		stmt->result->fields=fields;

		for (int i=0; i<colcount; i++) {

			fields[i].name=const_cast<char *>(
					sqlrcur->getColumnName(i));
			fields[i].table="";
			fields[i].def="";

			#if defined(COMPAT_MYSQL_4_0) || \
				defined(COMPAT_MYSQL_4_1) || \
				defined(COMPAT_MYSQL_5_0)
  			fields[i].org_table="";
  			fields[i].db="";
			#if defined(COMPAT_MYSQL_4_1) || \
				defined(COMPAT_MYSQL_5_0)
  			fields[i].catalog="";
  			fields[i].org_name=const_cast<char *>(
						sqlrcur->getColumnName(i));
			fields[i].name_length=
				charstring::length(fields[i].name);
			fields[i].org_name_length=
				charstring::length(fields[i].org_name);
			fields[i].table_length=
				charstring::length(fields[i].table);
			fields[i].org_table_length=
				charstring::length(fields[i].org_table);
			fields[i].db_length=
				charstring::length(fields[i].db);
			fields[i].catalog_length=
				charstring::length(fields[i].catalog);
			fields[i].def_length=
				charstring::length(fields[i].def);
			// FIXME: need a character set number here
			fields[i].charsetnr=0;
			#endif
			#endif

			// figure out the column type
			const char	*columntypestring=
						sqlrcur->getColumnType(i);
			enum enum_field_types	columntype=
					map_col_type(columntypestring);
			fields[i].type=columntype;

			fields[i].length=sqlrcur->getColumnLength(i);
			fields[i].max_length=sqlrcur->getLongest(i);

			// figure out the flags
			unsigned int	flags=0;
			if (sqlrcur->getColumnIsNullable(i)) {
				#define NOT_NULL_FLAG	1
				flags|=NOT_NULL_FLAG;
			}
			if (sqlrcur->getColumnIsPrimaryKey(i)) {
				#define PRI_KEY_FLAG	2
				flags|=PRI_KEY_FLAG;
			}
			if (sqlrcur->getColumnIsUnique(i)) {
				#define UNIQUE_KEY_FLAG 4
				flags|=UNIQUE_KEY_FLAG;
			}
			if (sqlrcur->getColumnIsPartOfKey(i)) {
				#define MULTIPLE_KEY_FLAG 8
				flags|=MULTIPLE_KEY_FLAG;
			}
			if (columntype==MYSQL_TYPE_TINY_BLOB ||
				columntype==MYSQL_TYPE_MEDIUM_BLOB ||
				columntype==MYSQL_TYPE_LONG_BLOB ||
				columntype==MYSQL_TYPE_BLOB) {
				#define BLOB_FLAG	16
				flags|=BLOB_FLAG;
			}
			if (sqlrcur->getColumnIsUnsigned(i) ||
				isUnsignedTypeChar(columntypestring)) {
				#define UNSIGNED_FLAG	32
				flags|=UNSIGNED_FLAG;
			}
			if (sqlrcur->getColumnIsZeroFilled(i)) {
				#define ZEROFILL_FLAG	64
				flags|=ZEROFILL_FLAG;
			}
			if (sqlrcur->getColumnIsBinary(i) ||
				isBinaryTypeChar(columntypestring)) {
				#define BINARY_FLAG	128
				flags|=BINARY_FLAG;
			}
			if (columntype==MYSQL_TYPE_ENUM) {
				#define ENUM_FLAG	256
				flags|=ENUM_FLAG;
			}
			if (sqlrcur->getColumnIsAutoIncrement(i)) {
				#define AUTO_INCREMENT_FLAG 512
				flags|=AUTO_INCREMENT_FLAG;
			}
			if (columntype==MYSQL_TYPE_TIMESTAMP) {
				#define TIMESTAMP_FLAG	1024
				flags|=TIMESTAMP_FLAG;
			}
			if (columntype==MYSQL_TYPE_SET) {
				#define SET_FLAG	2048
				flags|=SET_FLAG;
			}
			if (isNumberTypeChar(columntypestring)) {
				#define NUM_FLAG	32768
				flags|=NUM_FLAG;
			}
			// Presumably these don't matter...
			// Intern; Part of some key
			//#define PART_KEY_FLAG	16384
			// Intern: Group field
			//#define GROUP_FLAG	32768
			// Intern: Used by sql_yacc
			//#define UNIQUE_FLAG	65536
			fields[i].flags=flags;

			fields[i].decimals=sqlrcur->getColumnPrecision(i);
		}
	} else {
		stmt->result->fields=NULL;
	}

	return retval;
}

unsigned long mysql_param_count(MYSQL_STMT *stmt) {
	debugFunction();
	return stmt->result->sqlrcur->countBindVariables();
}

MYSQL_RES *mysql_param_result(MYSQL_STMT *stmt) {
	debugFunction();
	// FIXME: The MySQL docs don't even explain this one
	return NULL;
}



int mysql_fetch(MYSQL_STMT *stmt) {
	debugFunction();

	MYSQL_ROW	row=mysql_fetch_row(stmt->result);
	if (!row) {
		return MYSQL_NO_DATA;
	}

	unsigned long	*lengths=mysql_fetch_lengths(stmt->result);

	for (uint32_t i=0; i<stmt->result->sqlrcur->colCount(); i++) {
		*(stmt->resultbinds[i].length)=lengths[i];
		if (!row[i]) {
			*(stmt->resultbinds[i].is_null)=true;
		} else {
			*(stmt->resultbinds[i].is_null)=false;
			rawbuffer::copy(stmt->resultbinds[i].buffer,
							row[i],lengths[i]);
		}
		stmt->resultbinds[i].buffer[lengths[i]]=(char)NULL;

		// FIXME: I think I'm supposed to convert to
		// some other type based on the column type...
		stmt->resultbinds[i].buffer_type=MYSQL_TYPE_STRING,
		stmt->resultbinds[i].buffer_length=lengths[i];
	}
	return 0;
}

int mysql_fetch_column(MYSQL_STMT *stmt, MYSQL_BIND *bind,
			unsigned int column, unsigned long offset) {
	debugFunction();
	// FIXME: The MySQL docs don't even explain this one.
	return 0;
}



MYSQL_RES *mysql_get_metadata(MYSQL_STMT *stmt) {
	debugFunction();
	return stmt->result;
}



my_bool mysql_send_long_data(MYSQL_STMT *stmt,
				unsigned int parameter_number,
				const char *data, unsigned long length) {
	debugFunction();
	return false;
}



my_ulonglong mysql_stmt_num_rows(MYSQL_STMT *stmt) {
	debugFunction();
	return mysql_num_rows(stmt->result);
}

my_ulonglong mysql_stmt_affected_rows(MYSQL_STMT *stmt) {
	debugFunction();
	return stmt->result->sqlrcur->affectedRows();
}

MYSQL_ROW_OFFSET mysql_stmt_row_seek(MYSQL_STMT *stmt,
					MYSQL_ROW_OFFSET offset) {
	debugFunction();
	return mysql_row_seek(stmt->result,offset);
}

MYSQL_ROW_OFFSET mysql_stmt_row_tell(MYSQL_STMT *stmt) {
	debugFunction();
	return mysql_row_tell(stmt->result);
}

void mysql_stmt_data_seek(MYSQL_STMT *stmt, my_ulonglong offset) {
	debugFunction();
	mysql_data_seek(stmt->result,offset);
}



my_bool mysql_stmt_close(MYSQL_STMT *stmt) {
	debugFunction();
	if (stmt) {
		// It would seem like we'd want to call mysql_free_result here,
		// but the mysql client calls it manually before calling
		// mysql_close(), so presumably that's how apps should act.
		//mysql_free_result(stmt->result);
		delete stmt;
		stmt=NULL;
	}
	return true;
}



unsigned int mysql_stmt_errno(MYSQL_STMT *stmt) {
	debugFunction();
	return stmt->result->errorno;
}

const char *mysql_stmt_error(MYSQL_STMT *stmt) {
	debugFunction();
	return stmt->result->sqlrcur->errorMessage();
}

const char *mysql_stmt_sqlstate(MYSQL_STMT *stmt) {
	debugFunction();
	return "";
}



int mysql_stmt_store_result(MYSQL_STMT *stmt) {
	debugFunction();
	return 0;
}

my_bool mysql_stmt_free_result(MYSQL_STMT *stmt) {
	debugFunction();
	mysql_free_result(stmt->result);
	return true;
}



my_bool mysql_stmt_reset(MYSQL_STMT *stmt) {
	debugFunction();
	stmt->result->sqlrcur->clearBinds();
	return true;
}

int unknownError(MYSQL *mysql) {
	mysql->errorno=CR_UNKNOWN_ERROR;
	mysql->error="Unknown MySQL error";
	return CR_UNKNOWN_ERROR;
}

}