HaxeFoundation.haxe/std/cs/db/AdoNet.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 cs.db;

import sys.db.*;
import cs.system.data.*;

class AdoNet {
	public static function create(cnx:IDbConnection, dbName:String):Connection {
		return new AdoConnection(cnx, dbName);
	}
}

private class AdoConnection implements Connection {
	private static var ids = 0;

	private var id:Int;

	private var cnx:IDbConnection;
	// escape handling
	private var escapeRegex:EReg;
	private var escapes:Array<IDbDataParameter>;
	private var name:String;
	private var command:IDbCommand;
	private var transaction:IDbTransaction;

	public function new(cnx, name:String) {
		this.id = cs.system.threading.Interlocked.Increment(ids);
		this.cnx = cnx;
		this.name = name;
		this.escapes = [];
		this.command = cnx.CreateCommand();
		this.escapeRegex = ~/@HX_ESCAPE(\d+)_(\d+)/;
	}

	public function close():Void {
		cnx.Close();
	}

	public function escape(s:String):String {
		var param = command.CreateParameter();
		var name = "@HX_ESCAPE" + id + "_" + escapes.push(param) + "";
		param.ParameterName = name;
		param.Value = s;
		return name;
	}

	public function quote(s:String):String {
		var param = command.CreateParameter();
		var name = "@HX_ESCAPE" + id + "_" + escapes.push(param) + "";
		param.ParameterName = name;
		param.Value = s;
		return name;
	}

	public function addValue(s:StringBuf, v:Dynamic) {
		if (Std.isOfType(v, Date)) {
			v = Std.string(v);
		} else if (Std.isOfType(v, haxe.io.Bytes)) {
			var bt:haxe.io.Bytes = v;
			v = bt.getData();
		}
		var param = command.CreateParameter();
		var name = "@HX_ESCAPE" + id + "_" + escapes.push(param) + "";
		param.ParameterName = name;
		param.Value = v;
		s.add(name);
	}

	public function lastInsertId():Int {
		var ret = cnx.CreateCommand();
		ret.CommandText = switch (name) {
			case 'SQLite':
				'SELECT last_insert_rowid()';
			case _:
				'SELECT @@IDENTITY';
		}
		ret.CommandType = CommandType.Text;
		var r = cast ret.ExecuteScalar();
		ret.Dispose();

		return r;
	}

	public function dbName():String {
		return name;
	}

	public function startTransaction():Void {
		if (this.transaction != null)
			throw 'Transaction already active';
		this.transaction = cnx.BeginTransaction();
	}

	public function commit():Void {
		if (this.transaction == null)
			throw 'No transaction was initiated';
		this.transaction.Commit();
	}

	public function rollback():Void {
		if (this.transaction == null)
			throw 'No transaction was initiated';
		this.transaction.Rollback();
	}

	private static function getFirstStatement(s:String) {
		var buf = new StringBuf();
		var hasData = false;
		var chr = 0, i = 0;
		inline function getch()
			return chr = StringTools.fastCodeAt(s, i++);
		while (!StringTools.isEof(getch())) {
			inline function peek() {
				var c = StringTools.fastCodeAt(s, i);
				if (StringTools.isEof(c))
					break;
				return c;
			}
			switch (chr) {
				case ' '.code | '\t'.code | '\n'.code:
					if (hasData)
						return buf.toString();
				case '-'.code if (peek() == '-'.code):
					if (hasData)
						return buf.toString();
					while (!StringTools.isEof(getch())) {
						if (chr == '\n'.code)
							break;
					}
				case '#'.code:
					if (hasData)
						return buf.toString();
					while (!StringTools.isEof(getch())) {
						if (chr == '\n'.code)
							break;
					}
				case '/'.code if (peek() == '*'.code):
					i++;
					if (hasData)
						return buf.toString();
					while (!StringTools.isEof(getch())) {
						if (chr == '*'.code && peek() == '/'.code) {
							i++;
							break;
						}
					}
				case _:
					hasData = true;
					buf.addChar(chr);
			}
		}
		return buf.toString();
	}

	public function request(s:String):ResultSet {
		var newst = new StringBuf();
		// cycle through the request string, adding any @HX_ESCAPE reference to the command
		var ret:ResultSet = null;
		var r = escapeRegex;
		var myid = id + "", escapes = escapes, elen = escapes.length;
		var cmd = this.command;
		try {
			while (r.match(s)) {
				var id = r.matched(1);
				#if debug
				if (id != myid)
					throw "Request quotes are only valid for one single request; They can't be cached.";
				#end

				newst.add(r.matchedLeft());
				var eid = Std.parseInt(r.matched(2));
				#if debug
				if (eid == null || eid > elen)
					throw "Invalid request quote ID " + eid;
				#end
				cmd.Parameters.Add(escapes[eid - 1]);
				newst.add(escapes[eid - 1].ParameterName);
				s = r.matchedRight();
			}
			newst.add(s);

			s = newst.toString();
			cmd.CommandText = s;

			var stmt = getFirstStatement(s).toLowerCase();
			if (stmt == 'select') {
				ret = new AdoResultSet(cmd.ExecuteReader());
			} else {
				cmd.ExecuteNonQuery();
				ret = EmptyResultSet.empty;
			}

			if (escapes.length != 0)
				this.escapes = [];
			this.id = cs.system.threading.Interlocked.Increment(ids);
			cmd.Dispose();
			this.command = cnx.CreateCommand();
			return ret;
		} catch (e:Dynamic) {
			if (escapes.length != 0)
				this.escapes = [];
			this.id = cs.system.threading.Interlocked.Increment(ids);
			try {
				cmd.Dispose();
			} catch (e:Dynamic) {}
			this.command = cnx.CreateCommand();
			cs.Lib.rethrow(e);
		}
		return null;
	}
}

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

	private var reader:IDataReader;
	private var didNext:Bool;
	private var names:Array<String>;
	private var types:Array<Class<Dynamic>>;

	public function new(reader) {
		this.reader = reader;
		this.names = [for (i in 0...reader.FieldCount) reader.GetName(i)];
		this.types = [for (i in 0...names.length) cs.Lib.fromNativeType(reader.GetFieldType(i))];
	}

	private function get_length() {
		return reader.Depth;
	}

	private function get_nfields() {
		return names.length;
	}

	public function hasNext():Bool {
		didNext = true;
		return reader.Read();
	}

	public function next():Dynamic {
		if (!didNext && !hasNext())
			return null;
		didNext = false;
		var ret = {}, names = names, types = types;
		for (i in 0...names.length) {
			var name = names[i], t = types[i], val:Dynamic = null;
			if (reader.IsDBNull(i)) {
				val = null;
			} else if (t == cs.system.Single) {
				val = reader.GetDouble(i);
			} else if (t == cs.system.DateTime || t == cs.system.TimeSpan) {
				var d = reader.GetDateTime(i);
				if (d != null)
					val = @:privateAccess Date.fromNative(d);
			} else if (t == cs.system.DBNull) {
				val = null;
			} else if (t == cs.system.Byte) {
				var v2:cs.StdTypes.UInt8 = reader.GetValue(i);
				val = cast(v2, Int);
			} else if (Std.string(t) == 'System.Byte[]') {
				val = haxe.io.Bytes.ofData(reader.GetValue(i));
			} else {
				val = reader.GetValue(i);
			}
			if (Std.isOfType(val, cs.system.DBNull))
				val = null;
			Reflect.setField(ret, name, val);
		}
		return ret;
	}

	public function results():List<Dynamic> {
		var l = new List();
		while (hasNext())
			l.add(next());
		return l;
	}

	public function getResult(n:Int):String {
		return reader.GetString(n);
	}

	public function getIntResult(n:Int):Int {
		return reader.GetInt32(n);
	}

	public function getFloatResult(n:Int):Float {
		return reader.GetDouble(n);
	}

	public function getFieldsNames():Null<Array<String>> {
		return names;
	}
}

private class EmptyResultSet implements ResultSet {
	public static var empty = new EmptyResultSet();

	public function new() {}

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

	private function get_length() {
		return 0;
	}

	private function get_nfields() {
		return 0;
	}

	public function hasNext():Bool
		return false;

	public function next():Dynamic
		return null;

	public function results():List<Dynamic>
		return new List();

	public function getResult(n:Int):String
		return null;

	public function getIntResult(n:Int):Int
		return 0;

	public function getFloatResult(n:Int):Float
		return 0;

	public function getFieldsNames():Null<Array<String>>
		return null;
}