HaxeFoundation.haxe/std/php/_std/sys/db/Mysql.hx

/*
 * Copyright (C)2005-2019 Haxe Foundation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

package sys.db;

import php.*;
import sys.db.*;
import php.db.*;
import php.db.Mysqli_result;

@:coreApi class Mysql {
	public static function connect(params:{
		host:String,
		?port:Int,
		user:String,
		pass:String,
		?socket:String,
		?database:String
	}):Connection {
		return new MysqlConnection(params);
	}
}

private class MysqlConnection implements Connection {
	var db:Mysqli;

	public function new(params:{
		host:String,
		?port:Int,
		user:String,
		pass:String,
		?socket:String,
		?database:String
	}):Void {
		if (params.port == null)
			params.port = Std.parseInt(Global.ini_get('mysqli.default_port'));
		if (params.socket == null)
			params.socket = Global.ini_get('mysqli.default_socket');
		if (params.database == null)
			params.database = "";

		db = new Mysqli(params.host, params.user, params.pass, params.database, params.port, params.socket);
	}

	public function request(s:String):ResultSet {
		var result = db.query(s);
		if (result == false)
			throw 'Failed to perform db query: ' + db.error;
		if (result == true) {
			return new WriteMysqlResultSet(db.affected_rows);
		}

		return new MysqlResultSet(result);
	}

	public function close():Void {
		db.close();
	}

	public function escape(s:String):String {
		return db.escape_string(s);
	}

	public function quote(s:String):String {
		if (s.indexOf("\000") >= 0)
			return "x'" + Global.bin2hex(s) + "'";
		return "'" + db.escape_string(s) + "'";
	}

	public function addValue(s:StringBuf, v:Dynamic):Void {
		if (Global.is_int(v) || Global.is_null(v)) {
			s.add(v);
		} else if (Global.is_bool(v)) {
			s.add(v ? 1 : 0);
		} else {
			s.add(quote(Std.string(v)));
		}
	}

	public function lastInsertId():Int {
		return db.insert_id;
	}

	public function dbName():String {
		return 'MySQL';
	}

	public function startTransaction():Void {
		var success = db.begin_transaction();
		if (!success)
			throw 'Failed to start transaction: ' + db.error;
	}

	public function commit():Void {
		var success = db.commit();
		if (!success)
			throw 'Failed to commit transaction: ' + db.error;
	}

	public function rollback():Void {
		var success = db.rollback();
		if (!success)
			throw 'Failed to rollback transaction: ' + db.error;
	}
}

private class MysqlResultSet implements ResultSet {
	static var hxAnonClassName = Boot.getHxAnon().phpClassName;

	public var length(get, null):Int;
	public var nfields(get, null):Int;

	var result:Mysqli_result;
	var fetchedRow:NativeAssocArray<Scalar>;
	var fieldsInfo:NativeAssocArray<MysqliFieldInfo>;

	public function new(result:Mysqli_result) {
		this.result = result;
	}

	public function hasNext():Bool {
		if (fetchedRow == null)
			fetchNext();
		return fetchedRow != null;
	}

	public function next():Dynamic {
		if (fetchedRow == null)
			fetchNext();
		return withdrawFetched();
	}

	public function results():List<Dynamic> {
		var list = new List();

		result.data_seek(0);
		var row = result.fetch_object(hxAnonClassName);
		while (row != null) {
			row = correctObjectTypes(row);
			list.add(row);
			row = result.fetch_object(hxAnonClassName);
		}

		return list;
	}

	public function getResult(n:Int):String {
		if (fetchedRow == null)
			fetchNext();
		return Global.array_values(fetchedRow)[n];
	}

	public function getIntResult(n:Int):Int {
		return Syntax.int(getResult(n));
	}

	public function getFloatResult(n:Int):Float {
		return Syntax.float(getResult(n));
	}

	public function getFieldsNames():Null<Array<String>> {
		var fields = result.fetch_fields();
		return [for (field in fields) field.name];
	}

	function fetchNext() {
		var row = result.fetch_assoc();
		if (row != null)
			fetchedRow = correctArrayTypes(row);
	}

	function withdrawFetched():Dynamic {
		if (fetchedRow == null)
			return null;
		var row = fetchedRow;
		fetchedRow = null;
		return Boot.createAnon(row);
	}

	function correctArrayTypes(row:NativeAssocArray<String>):NativeAssocArray<Scalar> {
		var fieldsInfo = getFieldsInfo();
		Syntax.foreach(row, function(field:String, value:String) {
			row[field] = correctType(value, fieldsInfo[field].type);
		});
		return cast row;
	}

	function correctObjectTypes(row:{}):{} {
		var fieldsInfo = getFieldsInfo();
		Syntax.foreach(row, function(field:String, value:String) {
			value = correctType(value, fieldsInfo[field].type);
			Syntax.setField(row, field, value);
		});
		return row;
	}

	inline function getFieldsInfo():NativeAssocArray<MysqliFieldInfo> {
		if (fieldsInfo == null) {
			fieldsInfo = cast Syntax.arrayDecl();
			Syntax.foreach(result.fetch_fields(), function(_, info) {
				fieldsInfo[info.name] = info;
			});
		}
		return fieldsInfo;
	}

	function correctType(value:String, type:Int):Scalar {
		if (value == null)
			return null;
		if (type == Const.MYSQLI_TYPE_BIT || type == Const.MYSQLI_TYPE_TINY || type == Const.MYSQLI_TYPE_SHORT || type == Const.MYSQLI_TYPE_LONG
			|| type == Const.MYSQLI_TYPE_INT24 || type == Const.MYSQLI_TYPE_CHAR) {
			return Syntax.int(value);
		}
		if (type == Const.MYSQLI_TYPE_DECIMAL
			|| type == Const.MYSQLI_TYPE_NEWDECIMAL
			|| type == Const.MYSQLI_TYPE_FLOAT
			|| type == Const.MYSQLI_TYPE_DOUBLE) {
			return Syntax.float(value);
		}
		return value;
	}

	function get_length()
		return result.num_rows;

	function get_nfields()
		return result.field_count;
}

private class WriteMysqlResultSet extends MysqlResultSet {
	var affectedRows:Int = 0;

	public function new(affectedRows:Int) {
		super(null);
		this.affectedRows = affectedRows;
	}

	override public function hasNext():Bool {
		return false;
	}

	override function fetchNext() {}

	override function get_length()
		return affectedRows;

	override function get_nfields()
		return 0;
}