HaxeFoundation.haxe/std/php/_std/sys/db/Sqlite.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 php.db.*;
import sys.db.*;

@:coreApi class Sqlite {
	public static function open(file:String):Connection {
		return new SQLiteConnection(file);
	}
}

private class SQLiteConnection implements Connection {
	var db:SQLite3;

	public function new(file:String) {
		db = new SQLite3(file);
		db.enableExceptions(true);
	}

	public function request(s:String):ResultSet {
		var result = db.query(s);
		return new SQLiteResultSet(result);
	}

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

	public function escape(s:String):String {
		return SQLite3.escapeString(s);
	}

	public function quote(s:String):String {
		if (s.indexOf("\000") >= 0)
			return "x'" + Global.bin2hex(s) + "'";
		return "'" + SQLite3.escapeString(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 Syntax.int(db.lastInsertRowID());
	}

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

	public function startTransaction():Void {
		db.query('BEGIN TRANSACTION');
	}

	public function commit():Void {
		db.query('COMMIT');
	}

	public function rollback():Void {
		db.query('ROLLBACK');
	}
}

private class SQLiteResultSet implements ResultSet {
	public var length(get, null):Int;
	public var nfields(get, null):Int;

	var _length:Int = 0;
	var _nfields:Int = 0;

	var loaded:Bool = false;
	var currentIndex:Int = 0;
	var rows:NativeIndexedArray<NativeAssocArray<Scalar>>;
	var result:SQLite3Result;
	var fetchedRow:NativeArray;
	var fieldsInfo:NativeAssocArray<Int>;

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

	public function hasNext():Bool {
		if (!loaded)
			load();
		return currentIndex < _length;
	}

	public function next():Dynamic {
		if (!loaded)
			load();
		var next:Dynamic = rows[currentIndex++];
		return Boot.createAnon(correctArrayTypes(next));
	}

	public function results():List<Dynamic> {
		if (!loaded)
			load();
		var list = new List();
		Syntax.foreach(rows, function(_, row) list.add(Boot.createAnon(correctArrayTypes(row))));
		return list;
	}

	public function getResult(n:Int):String {
		if (!loaded)
			load();
		if (!hasNext())
			return null;
		return Global.array_values(rows[currentIndex])[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 fieldsInfo = getFieldsInfo();
		return Global.array_keys(fieldsInfo);
	}

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

	inline function getFieldsInfo():NativeAssocArray<Int> {
		if (fieldsInfo == null) {
			fieldsInfo = cast Syntax.arrayDecl();
			for (i in 0...nfields) {
				fieldsInfo[result.columnName(i)] = result.columnType(i);
			}
		}
		return fieldsInfo;
	}

	function load() {
		loaded = true;
		_nfields = result.numColumns();
		getFieldsInfo();
		fetchAll();
	}

	function correctType(value:String, type:Int):Scalar {
		if (value == null)
			return null;
		if (type == Const.SQLITE3_INTEGER)
			return Syntax.int(value);
		if (type == Const.SQLITE3_FLOAT)
			return Syntax.float(value);
		return value;
	}

	function fetchAll() {
		rows = Syntax.arrayDecl();
		var index = 0;
		var row = result.fetchArray(Const.SQLITE3_ASSOC);
		while (row != false) {
			rows[index] = correctArrayTypes(row);
			row = result.fetchArray(Const.SQLITE3_ASSOC);
			index++;
		}
		_length = index;
	}

	function get_length()
		return _length;

	function get_nfields()
		return _nfields;
}