added spod_macro support

doc/CHANGES.txt

@@ -12,6 +12,7 @@
 	all : bugfix when optimizing inlined immediate function call
 	all : fixed "using" on macro function
 	all : allowed member macros functions (called as static)
+	neko : added spod_macro support
 
 2011-01-30: 2.07
 	all : fixed completion support with --remap

std/neko/db/MacroManager.hx

@@ -0,0 +1,512 @@
+/*
+ * Copyright (c) 2005, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package neko.db;
+import Reflect;
+import neko.db.Connection;
+
+/**
+	SPOD Manager : the persistent object database manager. See the tutorial on
+	haXe website to learn how to use SPOD.
+**/
+#if !macro @:build(neko.db.SpodData.addRtti()) #end
+class MacroManager<T : Object> {
+
+	/* ----------------------------- STATICS ------------------------------ */
+	public static var cnx(default,setConnection) : Connection;
+	private static var object_cache : Hash<Object> = new Hash();
+	private static var init_list : List<Manager<Dynamic>> = new List();
+	private static var cache_field = "__cache__";
+	private static var no_update : Dynamic = function() { throw "Cannot update not locked object"; }
+	private static var LOCKS = ["","",""];
+	private static var KEYWORDS = {
+		var h = new Hash();
+		for( k in ["read","write","desc","out","group","version","option",
+				"primary","exists","from","key","keys","limit","lock","use",
+				"create","order","range"] )
+			h.set(k,true);
+		h;
+	}
+
+	private static function setConnection( c : Connection ) {
+		Reflect.setField(Manager,"cnx",c);
+		if( c != null ) {
+			if( c.dbName() == "MySQL" ) {
+				LOCKS[1] = " LOCK IN SHARE MODE";
+				LOCKS[2] = " FOR UPDATE";
+			} else {
+				LOCKS[1] = "";
+				LOCKS[2] = "";
+			}
+		}
+		return c;
+	}
+
+	/* ---------------------------- BASIC API ----------------------------- */
+	var table_infos : SpodInfos;
+	var table_name : String;
+	var table_fields : List<String>;
+	var table_keys : Array<String>;
+	var class_proto : { prototype : Dynamic };
+	var lock_mode : Int;
+
+	public function new( classval : Class<T> ) {
+		var m : Array<Dynamic> = haxe.rtti.Meta.getType(classval).rtti;
+		if( m == null ) throw "Missing @rtti for class " + Type.getClassName(classval);
+		table_infos = haxe.Unserializer.run(m[0]);
+		table_name = quoteField(table_infos.name);
+		table_keys = table_infos.key;
+		class_proto = cast classval;
+		lock_mode = 2;
+
+		// get the proto fields not marked private (excluding methods)
+		table_fields = new List();
+		for( f in table_infos.fields )
+			table_fields.add(f.name);
+
+		// set the manager and ready for further init
+		class_proto.prototype.local_manager = this;
+		init_list.add(this);
+	}
+
+	public function all( ?lock: Bool ) : List<T> {
+		return unsafeObjects("SELECT * FROM " + table_name,lock);
+	}
+
+	@:macro public function get(ethis,id,?lock:haxe.macro.Expr.ExprRequire<Bool>) : #if macro haxe.macro.Expr #else haxe.macro.Expr.ExprRequire<T> #end {
+		return SpodData.macroGet(ethis,id,lock);
+	}
+
+	@:macro public function object(ethis, cond, ?lock:haxe.macro.Expr.ExprRequire<Bool>) : #if macro haxe.macro.Expr #else haxe.macro.Expr.ExprRequire<T> #end {
+		return SpodData.macroSearch(ethis, cond, lock, true);
+	}
+
+	@:macro public function search(ethis, cond, ?lock:haxe.macro.Expr.ExprRequire<Bool>) : #if macro haxe.macro.Expr #else haxe.macro.Expr.ExprRequire<List<T>> #end {
+		return SpodData.macroSearch(ethis, cond, lock);
+	}
+
+	@:macro public function count(ethis, cond) : #if macro haxe.macro.Expr #else haxe.macro.Expr.ExprRequire<Int> #end {
+		return SpodData.macroCount(ethis, cond);
+	}
+
+	@:macro public function delete(ethis, cond) : #if macro haxe.macro.Expr #else haxe.macro.Expr.ExprRequire<Void> #end {
+		return SpodData.macroDelete(ethis, cond);
+	}
+	
+	// for backward compatibility
+	#if spod_compat
+	@:macro public function getWithKeys(ethis,cond,?lock:haxe.macro.Expr.ExprRequire<Bool>) : #if macro haxe.macro.Expr #else haxe.macro.Expr.ExprRequire<T> #end {
+		return SpodData.macroGet(ethis,cond,lock);
+	}
+
+	@:macro public function objects(ethis, cond, ?lock:haxe.macro.Expr.ExprRequire<Bool>) : #if macro haxe.macro.Expr #else haxe.macro.Expr.ExprRequire<List<T>> #end {
+		return SpodData.macroSearch(ethis, cond, lock);
+	}
+	#end
+
+	function quote( s : String ) : String {
+		return cnx.quote( s );
+	}
+
+	/* -------------------------- SPODOBJECT API -------------------------- */
+
+	function doInsert( x : T ) {
+		unmake(x);
+		var s = new StringBuf();
+		var fields = new List();
+		var values = new List();
+		for( f in table_fields ) {
+			var v = Reflect.field(x,f);
+			if( v != null ) {
+				fields.add(quoteField(f));
+				values.add(v);
+			}
+		}
+		s.add("INSERT INTO ");
+		s.add(table_name);
+		s.add(" (");
+		s.add(fields.join(","));
+		s.add(") VALUES (");
+		var first = true;
+		for( v in values ) {
+			if( first )
+				first = false;
+			else
+				s.add(", ");
+			cnx.addValue(s,v);
+		}
+		s.add(")");
+		unsafeExecute(s.toString());
+		// table with one key not defined : suppose autoincrement
+		if( table_keys.length == 1 && Reflect.field(x,table_keys[0]) == null )
+			Reflect.setField(x,table_keys[0],cnx.lastInsertId());
+		addToCache(x);
+	}
+
+	function doUpdate( x : T ) {
+		unmake(x);
+		var s = new StringBuf();
+		s.add("UPDATE ");
+		s.add(table_name);
+		s.add(" SET ");
+		var cache = Reflect.field(x,cache_field);
+		var mod = false;
+		for( f in table_fields ) {
+			var v = Reflect.field(x,f);
+			var vc = Reflect.field(cache,f);
+			if( v != vc ) {
+				if( mod )
+					s.add(", ");
+				else
+					mod = true;
+				s.add(quoteField(f));
+				s.add(" = ");
+				cnx.addValue(s,v);
+				Reflect.setField(cache,f,v);
+			}
+		}
+		if( !mod )
+			return;
+		s.add(" WHERE ");
+		addKeys(s,x);
+		unsafeExecute(s.toString());
+	}
+
+	function doDelete( x : T ) {
+		var s = new StringBuf();
+		s.add("DELETE FROM ");
+		s.add(table_name);
+		s.add(" WHERE ");
+		addKeys(s,x);
+		unsafeExecute(s.toString());
+		removeFromCache(x);
+	}
+
+
+	function doSync( i : T ) {
+		object_cache.remove(makeCacheKey(i));
+		var s = new StringBuf();
+		s.add("SELECT * FROM");
+		s.add(table_name);
+		s.add(" WHERE ");
+		addKeys(s, i);
+		var i2 = unsafeObject(s.toString(),(cast i).update != no_update);
+		// delete all fields
+		for( f in Reflect.fields(i) )
+			Reflect.deleteField(i,f);
+		// copy fields from new object
+		for( f in Reflect.fields(i2) )
+			Reflect.setField(i,f,Reflect.field(i2,f));
+		// set same field-cache
+		Reflect.setField(i,cache_field,Reflect.field(i2,cache_field));
+		// rebuild in case it's needed
+		make(i);
+		addToCache(i);
+	}
+
+	function objectToString( it : T ) : String {
+		var s = new StringBuf();
+		s.add(table_name);
+		if( table_keys.length == 1 ) {
+			s.add("#");
+			s.add(Reflect.field(it,table_keys[0]));
+		} else {
+			s.add("(");
+			var first = true;
+			for( f in table_keys ) {
+				if( first )
+					first = false;
+				else
+					s.add(",");
+				s.add(quoteField(f));
+				s.add(":");
+				s.add(Reflect.field(it,f));
+			}
+			s.add(")");
+		}
+		return s.toString();
+	}
+
+	/* ---------------------------- INTERNAL API -------------------------- */
+
+	function cacheObject( x : T, lock : Bool ) {
+		addToCache(x);
+		untyped __dollar__objsetproto(x,class_proto.prototype);
+		Reflect.setField(x,cache_field,untyped __dollar__new(x));
+		if( !lock )
+			x.update = no_update;
+	}
+
+	function make( x : T ) {
+	}
+
+	function unmake( x : T ) {
+	}
+
+	function quoteField(f : String) {
+		return KEYWORDS.exists(f.toLowerCase()) ? "`"+f+"`" : f;
+	}
+
+	function addKeys( s : StringBuf, x : {} ) {
+		var first = true;
+		for( k in table_keys ) {
+			if( first )
+				first = false;
+			else
+				s.add(" AND ");
+			s.add(quoteField(k));
+			s.add(" = ");
+			var f = Reflect.field(x,k);
+			if( f == null )
+				throw ("Missing key "+k);
+			cnx.addValue(s,f);
+		}
+	}
+
+	function unsafeExecute( sql : String ) {
+		return cnx.request(sql);
+	}
+
+	public function unsafeObject( sql : String, lock : Bool ) : T {
+		if( lock != false ) {
+			lock = true;
+			sql += getLockMode();
+		}
+		var r = cnx.request(sql).next();
+		if( r == null )
+			return null;
+		var c = getFromCache(r,lock);
+		if( c != null )
+			return c;
+		cacheObject(r,lock);
+		make(r);
+		return r;
+	}
+
+	public function unsafeObjects( sql : String, lock : Bool ) : List<T> {
+		if( lock != false ) {
+			lock = true;
+			sql += getLockMode();
+		}
+		var l = cnx.request(sql).results();
+		var l2 = new List<T>();
+		for( x in l ) {
+			var c = getFromCache(x,lock);
+			if( c != null )
+				l2.add(c);
+			else {
+				cacheObject(x,lock);
+				make(x);
+				l2.add(x);
+			}
+		}
+		return l2;
+	}
+
+	public function unsafeCount( sql : String ) {
+		return unsafeExecute(sql).getIntResult(0);
+	}
+
+	public function unsafeDelete( sql : String ) {
+		unsafeExecute(sql);
+	}
+	
+	public function dynamicSearch( x : {}, ?lock : Bool ) : List<T> {
+		var s = new StringBuf();
+		s.add("SELECT * FROM ");
+		s.add(table_name);
+		s.add(" WHERE ");
+		addCondition(s,x);
+		return unsafeObjects(s.toString(),lock);
+	}
+
+	function addCondition(s : StringBuf,x) {
+		var first = true;
+		if( x != null )
+			for( f in Reflect.fields(x) ) {
+				if( first )
+					first = false;
+				else
+					s.add(" AND ");
+				s.add(quoteField(f));
+				var d = Reflect.field(x,f);
+				if( d == null )
+					s.add(" IS NULL");
+				else {
+					s.add(" = ");
+					cnx.addValue(s,d);
+				}
+			}
+		if( first )
+			s.add("1");
+	}
+
+	/* --------------------------- MISC API  ------------------------------ */
+
+	inline function getLockMode() {
+		return LOCKS[lock_mode];
+	}
+
+	public function setLockMode( exclusive, readShared ) {
+		lock_mode = exclusive ? 2 : (readShared ? 1 : 0);
+	}
+
+	public function dbClass() : Class<Dynamic> {
+		return cast class_proto;
+	}
+
+	/* --------------------------- INIT / CLEANUP ------------------------- */
+
+	public static function initialize() {
+		var l = init_list;
+		init_list = new List();
+		for( m in l )
+			for( r in m.table_infos.relations )
+				m.initRelation(r);
+	}
+
+	public static function cleanup() {
+		object_cache = new Hash();
+	}
+
+	function initRelation( r : SpodInfos.SpodRelation ) {
+		// setup getter/setter
+		var spod : Dynamic = Type.resolveClass(r.type);
+		if( spod == null ) throw "Missing spod type " + r.type;
+		var manager : Manager<Dynamic> = spod.manager;
+		var hprop = "__"+r.prop;
+		var hkey = r.key;
+		var lock = r.lock;
+		if( manager == null || manager.table_keys == null ) throw ("Invalid manager for relation "+table_name+":"+r.prop);
+		if( manager.table_keys.length != 1 ) throw ("Relation " + r.prop + "(" + r.key + ") on a multiple key table");
+		var sql = "SELECT * FROM " + manager.table_name + " WHERE " + quoteField(manager.table_keys[0]) + " = ";
+		Reflect.setField(class_proto.prototype,"get_"+r.prop,function() {
+			var othis = untyped this;
+			var f = Reflect.field(othis,hprop);
+			if( f != null )
+				return f;
+			var id = Reflect.field(othis, hkey);
+			if( id == null )
+				return null;
+			f = manager.unsafeObject(sql+id,lock);
+			// it's highly possible that in that case the object has been inserted
+			// after we started our transaction : in that case, let's lock it, since
+			// it's still better than returning 'null' while it exists
+			if( f == null && id != null && !lock )
+				f = manager.unsafeObject(sql+id,true);
+			Reflect.setField(othis,hprop,f);
+			return f;
+		});
+		Reflect.setField(class_proto.prototype,"set_"+r.prop,function(f) {
+			var othis = untyped this;
+			Reflect.setField(othis,hprop,f);
+			Reflect.setField(othis,hkey,Reflect.field(f,manager.table_keys[0]));
+			return f;
+		});
+	}
+
+	/* ---------------------------- OBJECT CACHE -------------------------- */
+
+	function makeCacheKey( x : T ) : String {
+		if( table_keys.length == 1 ) {
+			var k = Reflect.field(x,table_keys[0]);
+			if( k == null )
+				throw("Missing key "+table_keys[0]);
+			return Std.string(k)+table_name;
+		}
+		var s = new StringBuf();
+		for( k in table_keys ) {
+			var v = Reflect.field(x,k);
+			if( k == null )
+				throw("Missing key "+k);
+			s.add(v);
+			s.add("#");
+		}
+		s.add(table_name);
+		return s.toString();
+	}
+
+	function addToCache( x : T ) {
+		object_cache.set(makeCacheKey(x),x);
+	}
+
+	function removeFromCache( x : T ) {
+		object_cache.remove(makeCacheKey(x));
+	}
+
+	function getFromCacheKey( key : String ) : T {
+		return cast object_cache.get(key);
+	}
+
+	function getFromCache( x : T, lock : Bool ) : T {
+		var c : Dynamic = object_cache.get(makeCacheKey(x));
+		if( c != null && lock && c.update == no_update ) {
+			// restore update method since now the object is locked
+			c.update = class_proto.prototype.update;
+			// and synchronize the fields since our result is up-to-date !
+			for( f in Reflect.fields(c) )
+				Reflect.deleteField(c,f);
+			for( f in Reflect.fields(x) )
+				Reflect.setField(c,f,Reflect.field(x,f));
+			// use the new object as our cache of fields
+			Reflect.setField(c,cache_field,x);
+			// remake object
+			make(c);
+		}
+		return c;
+	}
+
+	/* ---------------------------- QUOTES -------------------------- */
+
+	static function quoteAny( v : Dynamic ) {
+		var s = new StringBuf();
+		cnx.addValue(s, v);
+		return s.toString();
+	}
+
+	public static inline function quoteInt( v : Int ) {
+		return quoteAny(v);
+	}
+
+	public static inline function quoteFloat( v : Float ) {
+		return quoteAny(v);
+	}
+
+	public static inline function quoteDate( v : Date ) {
+		return quoteAny(v);
+	}
+
+	public static inline function quoteString( v : String ) {
+		return quoteAny(v);
+	}
+
+	public static inline function quoteBool( v : Bool ) {
+		return quoteAny(v);
+	}
+
+	public static inline function quoteBytes( v : String ) {
+		return quoteAny(v);
+	}
+
+}

std/neko/db/Manager.hx

@@ -28,6 +28,10 @@ package neko.db;
 
 typedef Manager<T : Object> = mt.db.ShardManager<T>;
 
+#elseif spod_macro
+
+typedef Manager<T : Object> = neko.db.MacroManager<T>;
+
 #else
 
 import Reflect;

std/neko/db/SpodData.hx

@@ -0,0 +1,703 @@
+package neko.db;
+import neko.db.SpodInfos;
+import haxe.macro.Expr;
+import haxe.macro.Type.VarAccess;
+#if macro
+import haxe.macro.Context;
+#end
+
+private typedef SqlFunction = {
+	var name : String;
+	var params : Array<SpodType>;
+	var ret : SpodType;
+	var sql : String;
+}
+
+private enum BuildError {
+	EExpr( e : Expr );
+}
+
+class SpodData {
+
+	static var inst : SpodData = null;
+
+	var cache : Hash<SpodInfos>;
+	var types : Hash<SpodType>;
+	var isNull : Bool;
+	var manager : Expr;
+	var current : SpodInfos;
+	var functions : Hash<SqlFunction>;
+
+	function new() {
+		cache = new Hash();
+		types = new Hash();
+		for( c in Type.getEnumConstructs(SpodType) ) {
+			var e : Dynamic = Reflect.field(SpodType, c);
+			if( Std.is(e, SpodType) )
+				types.set("S"+c.substr(1), e);
+		}
+		types.remove("SNull");
+		functions = new Hash();
+		for( f in [
+			{ name : "now", params : [], ret : DDateTime, sql : "NOW($)" },
+			{ name : "curdate", params : [], ret : DDate, sql : "CURDATE($)" },
+			{ name : "seconds", params : [DFloat], ret : DInterval, sql : "INTERVAL $ SECOND" },
+			{ name : "minutes", params : [DFloat], ret : DInterval, sql : "INTERVAL $ MINUTE" },
+			{ name : "hours", params : [DFloat], ret : DInterval, sql : "INTERVAL $ HOUR" },
+			{ name : "days", params : [DFloat], ret : DInterval, sql : "INTERVAL $ DAY" },
+			{ name : "months", params : [DFloat], ret : DInterval, sql : "INTERVAL $ MONTH" },
+			{ name : "years", params : [DFloat], ret : DInterval, sql : "INTERVAL $ YEAR" },
+			{ name : "date", params : [DDateTime], ret : DDate, sql : "DATE($)" },
+		])
+			functions.set(f.name, f);
+	}
+
+	public dynamic function error( msg : String, pos : Position ) : Dynamic {
+		#if macro
+		Context.error(msg, pos);
+		#else
+		throw msg;
+		#end
+		return null;
+	}
+	
+	function makeInt( t : haxe.macro.Type ) {
+		switch( t ) {
+		case TInst(c, _):
+			var name = c.toString();
+			if( name.charAt(0) == "I" )
+				return Std.parseInt(name.substr(1));
+		default:
+		}
+		throw "Unsupported " + Std.string(t);
+	}
+
+	function makeSpod( t : haxe.macro.Type ) {
+		switch( t ) {
+		case TInst(c, p):
+			var name = c.toString();
+			var cl = c.get();
+			if( cl.superClass != null && cl.superClass.t.toString() == "neko.db.Object" )
+				return name;
+		case TType(t, p):
+			var name = t.toString();
+			if( p.length == 1 && (name == "Null" || name == "neko.db.SNull" || name == "mt.db.SNull") ) {
+				isNull = true;
+				return makeSpod(p[0]);
+			}
+		default:
+		}
+		return null;
+	}
+	
+	function makeType( t : haxe.macro.Type ) {
+		switch( t ) {
+		case TInst(c, p):
+			var name = c.toString();
+			return switch( name ) {
+			case "Int": DInt;
+			case "Float": DFloat;
+			case "String": DText;
+			case "Date": DDateTime;
+			default: throw "Unsupported " + name;
+			}
+		case TEnum(e, p):
+			var name = e.toString();
+			switch( name ) {
+			case "Bool": DBool;
+			default: throw "Unsupported " + name;
+			}
+		case TType(t, p):
+			var name = t.toString();
+			if( StringTools.startsWith(name, "neko.db.") )
+				name = name.substr(8);
+			else if( StringTools.startsWith(name, "mt.db.") )
+				name = name.substr(6);
+			var k = types.get(name);
+			if( k != null ) return k;
+			if( p.length == 1 )
+				switch( name ) {
+				case "SString": return DString(makeInt(p[0]));
+				case "SNull", "Null": isNull = true; return makeType(p[0]);
+				default:
+				}
+			throw "Unsupported " + name;
+		default:
+		}
+		throw "Unsupported " + Std.string(t);
+	}
+	
+	function makeIdent( e : Expr ) {
+		return switch( e.expr ) {
+		case EConst(c):
+			switch( c ) {
+			case CIdent(s), CType(s): s;
+			default: error("Identifier expected", e.pos);
+			}
+		default: error("Identifier expected", e.pos);
+		}
+	}
+
+	function getSpodInfos( c : haxe.macro.Type.Ref<haxe.macro.Type.ClassType> ) : SpodInfos {
+		var cname = c.toString();
+		var i = cache.get(cname);
+		if( i != null ) return i;
+		i = {
+			key : null,
+			name : cname.split(".").pop(), // remove package name
+			fields : [],
+			hfields : new Hash(),
+			relations : [],
+			indexes : [],
+		};
+		var c = c.get();
+		var fieldsPos = new Hash();
+		for( f in c.fields.get() ) {
+			fieldsPos.set(f.name, f.pos);
+			switch( f.kind ) {
+			case FMethod(_):
+				// skip methods
+				continue;
+			case FVar(g, s):
+				// skip not-db fields
+				if( f.meta.has(":skip") )
+					continue;
+				// handle relations
+				if( f.meta.has(":relation") ) {
+					if( !Type.enumEq(g,AccCall("get_" + f.name)) || !Type.enumEq(s,AccCall("set_" + f.name)) )
+						error("Relation should be (dynamic,dynamic)", f.pos);
+					for( m in f.meta.get() ) {
+						if( m.name != ":relation" ) continue;
+						if( m.params.length == 0 ) error("Missing relation key", m.pos);
+						var params = [];
+						for( p in m.params )
+							params.push({ i : makeIdent(p), p : p.pos });
+						isNull = false;
+						var t = makeSpod(f.type);
+						if( t == null ) error("Relation type should be a neko.db.Object", f.pos);
+						var r = {
+							prop : f.name,
+							key : params.shift().i,
+							type : t,
+							cascade : false,
+							lock : false,
+							isNull : isNull,
+						};
+						// setup flags
+						for( p in params )
+							switch( p.i ) {
+							case "lock": r.lock = true;
+							case "cascade": r.cascade = true;
+							default: error("Unknown relation flag", p.p);
+							}
+						i.relations.push(r);
+					}
+					continue;
+				}
+				switch( g ) {
+				case AccCall(_):
+					error("Relation should be defined with @:relation(key)", f.pos);
+				default:
+				}
+			}
+			isNull = false;
+			var fi = {
+				name : f.name,
+				t : try makeType(f.type) catch( e : Dynamic ) error(Std.string(e),f.pos),
+				isNull : isNull,
+			};
+			switch( fi.t ) {
+			case DId, DUId: if( i.key == null ) i.key = [fi.name] else error("Multiple table id declaration", f.pos);
+			default:
+			}
+			i.fields.push(fi);
+			i.hfields.set(fi.name, fi);
+		}
+		// create fields for undeclared relations keys :
+		for( r in i.relations ) {
+			var f = i.hfields.get(r.key);
+			if( f == null ) {
+				f = {
+					name : r.key,
+					t : DInt,
+					isNull : r.isNull,
+				};
+				i.fields.push(f);
+				i.hfields.set(f.name, f);
+			} else {
+				var pos = fieldsPos.get(f.name);
+				if( f.t != DInt ) error("Relation key should be SInt", pos);
+				if( f.isNull != r.isNull ) error("Relation and field should have same nullability", pos);
+			}
+		}
+		// process class metadata
+		for( m in c.meta.get() )
+			switch( m.name ) {
+			case ":id":
+				if( i.key != null ) error("Multiple unique id", m.pos);
+				i.key = [];
+				for( p in m.params ) {
+					var id = makeIdent(p);
+					if( !i.hfields.exists(id) )
+						error("This field does not exists", p.pos);
+					i.key.push(id);
+				}
+				if( i.key.length == 0 ) error("Invalid :id", m.pos);
+			case ":index":
+				var idx = [];
+				for( p in m.params ) idx.push(makeIdent(p));
+				var unique = idx[idx.length - 1] == "unique";
+				if( unique ) idx.pop();
+				if( idx.length == 0 ) error("Invalid :index", m.pos);
+				for( k in 0...idx.length )
+					if( !i.hfields.exists(idx[k]) )
+						error("This field does not exists", m.params[k].pos);
+				i.indexes.push( { keys : idx, unique : unique } );
+			default:
+			}
+		// check primary key defeined
+		if( i.key == null )
+			error("Table is missing unique id, use either SId or @:id", c.pos);
+		cache.set(cname, i);
+		return i;
+	}
+	
+	function quoteField( f : String ) {
+		var m : { private var KEYWORDS : Hash<Bool>; } = Manager;
+		return m.KEYWORDS.exists(f.toLowerCase()) ? "`"+f+"`" : f;
+	}
+	
+	function initManager( pos : Position ) {
+		manager = { expr : EType({ expr : EField({ expr : EConst(CIdent("neko")), pos : pos },"db"), pos : pos }, "Manager"), pos : pos };
+	}
+
+	inline function makeString( s : String, pos ) {
+		return { expr : EConst(CString(s)), pos : pos };
+	}
+
+	inline function makeOp( op : String, e1, e2, pos ) {
+		return sqlAdd(sqlAddString(e1,op),e2,pos);
+	}
+	
+	inline function sqlAdd( e1 : Expr, e2 : Expr, pos : Position ) {
+		return { expr : EBinop(OpAdd, e1, e2), pos : pos };
+	}
+	
+	inline function sqlAddString( sql : Expr, s : String ) {
+		return { expr : EBinop(OpAdd, sql, makeString(s,sql.pos)), pos : sql.pos };
+	}
+	
+	function sqlQuoteValue( v : Expr, t : SpodType ) {
+		var meth = switch( t ) {
+		case DId, DInt, DUId, DUInt, DEncoded, DFlags(_): "quoteInt";
+		case DBigId, DBigInt, DSingle, DFloat: "quoteFloat";
+		case DBool: "quoteBool";
+		case DString(_), DTinyText, DSmallText, DText, DSerialized: "quoteString";
+		case DDate, DDateTime: "quoteDate";
+		case DSmallBinary, DLongBinary, DBinary, DBytes(_), DNekoSerialized: "quoteBytes";
+		case DInterval, DNull: throw "assert";
+		};
+		return { expr : ECall( { expr : EField(manager, meth), pos : v.pos }, [v]), pos : v.pos }
+	}
+	
+	inline function sqlAddValue( sql : Expr, v : Expr, t : SpodType ) {
+		return { expr : EBinop(OpAdd, sql, sqlQuoteValue(v,t)), pos : sql.pos };
+	}
+	
+	function unifyClass( t : SpodType ) {
+		return switch( t ) {
+		case DId, DInt, DUId, DUInt, DEncoded, DFlags(_): 0;
+		case DBigId, DBigInt, DSingle, DFloat: 1;
+		case DBool: 2;
+		case DString(_), DTinyText, DSmallText, DText, DSerialized: 3;
+		case DDate, DDateTime: 4;
+		case DSmallBinary, DLongBinary, DBinary, DBytes(_), DNekoSerialized: 5;
+		case DInterval: 6;
+		case DNull: 7;
+		};
+	}
+	
+	function tryUnify( t, rt ) {
+		if( t == rt ) return true;
+		var c = unifyClass(t);
+		var rc = unifyClass(rt);
+		return c == rc || (c == 0 && rc == 1); // allow Int-to-Float expansion
+	}
+	
+	function typeStr( t : SpodType ) {
+		return Std.string(t).substr(1);
+	}
+	
+	function canStringify( t : SpodType ) {
+		return switch( unifyClass(t) ) {
+		case 0, 1, 2, 3, 4, 5, 7: true;
+		default: false;
+		};
+	}
+	
+	function unify( t : SpodType, rt : SpodType, pos : Position ) {
+		if( !tryUnify(t, rt) )
+			error(typeStr(t) + " should be " + typeStr(rt), pos);
+	}
+	
+	function buildCmp( op, e1, e2, pos ) {
+		var r1 = buildCond(e1);
+		var r2 = buildCond(e2);
+		unify(r2.t, r1.t, e2.pos);
+		if( !tryUnify(r1.t, DInt) && !tryUnify(r1.t, DDate) && !tryUnify(r1.t, DText) )
+			unify(r1.t, DInt, e1.pos);
+		return { sql : makeOp(op, r1.sql, r2.sql, pos), t : DBool, n : r1.n || r2.n };
+	}
+	
+	function buildNum( op, e1, e2, pos ) {
+		var r1 = buildCond(e1);
+		var r2 = buildCond(e2);
+		var c1 = unifyClass(r1.t);
+		var c2 = unifyClass(r2.t);
+		if( c1 > 1 ) {
+			if( op == "-" && tryUnify(r1.t, DDateTime) && tryUnify(r2.t,DInterval) )
+				return { sql : makeOp(op, r1.sql, r2.sql, pos), t : DDateTime, n : r1.n };
+			unify(r1.t, DInt, e1.pos);
+		}
+		if( c2 > 1 ) unify(r2.t, DInt, e2.pos);
+		return { sql : makeOp(op, r1.sql, r2.sql, pos), t : (c1 + c2) == 0 ? DInt : DFloat, n : r1.n || r2.n };
+	}
+	
+	function buildInt( op, e1, e2, pos ) {
+		var r1 = buildCond(e1);
+		var r2 = buildCond(e2);
+		unify(r1.t, DInt, e1.pos);
+		unify(r2.t, DInt, e2.pos);
+		return { sql : makeOp(op, r1.sql, r2.sql, pos), t : DInt, n : r1.n || r2.n };
+	}
+	
+	function buildEq( eq, e1, e2, pos ) {
+		var r1 = buildCond(e1);
+		var r2 = buildCond(e2);
+		if( r2.t == DNull ) {
+			if( !r1.n )
+				error("Expression can't be null", e1.pos);
+			return { sql : sqlAddString(r1.sql, eq ? " IS NULL" : " IS NOT NULL"), t : DBool, n : false };
+		} else {
+			unify(r2.t, r1.t, e2.pos);
+			unify(r1.t, r2.t, e1.pos);
+		}
+		// use some different operators if there is a possibility for NULL matching
+		var isNull = r1.n || r2.n;
+		var sql;
+		if( isNull ) {
+			sql = makeOp(" <=> ", r1.sql, r2.sql, pos);
+			if( !eq )
+				sql = sqlAdd(makeString("NOT(", pos), sqlAddString(sql, ")"), pos);
+		} else
+			sql = makeOp(eq?" = ":" != ", r1.sql, r2.sql, pos);
+		return { sql : sql, t : DBool, n : isNull };
+	}
+	
+	function buildDefault( cond : Expr ) {
+		var t = try Context.typeof(cond) catch( e : Dynamic ) throw BuildError.EExpr(cond);
+		var d = try makeType(t) catch( e : Dynamic ) try makeType(Context.follow(t)) catch( e : Dynamic ) error("Unsupported type " + Std.string(t), cond.pos);
+		return { sql : sqlQuoteValue(cond, d), t : d, n : false }; // assume values are never checked for null's
+	}
+	
+	function buildCond( cond : Expr ) {
+		var sql = null;
+		var p = cond.pos;
+		switch( cond.expr ) {
+		case EObjectDecl(fl):
+			var first = true;
+			var sql = makeString("(", p);
+			for( f in fl ) {
+				var fi = current.hfields.get(f.field);
+				if( fi == null ) error("No database field " + f.field, p);
+				if( first )
+					first = false;
+				else
+					sql = sqlAddString(sql, " AND ");
+				sql = sqlAddString(sql, quoteField(fi.name) + " = ");
+				sql = sqlAddValue(sql, f.expr, fi.t);
+			}
+			if( first ) sqlAddString(sql, "TRUE");
+			sql = sqlAddString(sql, ")");
+			return { sql : sql, t : DBool, n : false };
+		case EParenthesis(e):
+			var r = buildCond(cond);
+			r.sql = sqlAdd(makeString("(", p), r.sql, p);
+			r.sql = sqlAddString(r.sql, ")");
+			return r;
+		case EBinop(op, e1, e2):
+			switch( op ) {
+			case OpAdd:
+				var r1 = buildCond(e1);
+				var r2 = buildCond(e2);
+				var rt = if( tryUnify(r1.t, DFloat) && tryUnify(r2.t, DFloat) )
+					tryUnify(r1.t, DInt) ? tryUnify(r2.t, DInt) ? DInt : DFloat : DFloat;
+				else if( (tryUnify(r1.t, DText) && canStringify(r2.t)) || (tryUnify(r2.t, DText) && canStringify(r1.t)) )
+					return { sql : sqlAddString(sqlAdd(sqlAddString(sqlAdd(makeString("CONCAT(",p),r1.sql,p),","),r2.sql,p),")"), t : DText, n : r1.n || r2.n }
+				else
+					error("Can't add " + typeStr(r1.t) + " and " + typeStr(r2.t), p);
+				return { sql : makeOp("+", r1.sql, r2.sql, p), t : rt, n : r1.n || r2.n };
+			case OpBoolAnd, OpBoolOr:
+				var r1 = buildCond(e1);
+				var r2 = buildCond(e2);
+				unify(r1.t, DBool, e1.pos);
+				unify(r2.t, DBool, e2.pos);
+				return { sql : makeOp(op == OpBoolAnd ? " AND " : " OR ", r1.sql, r2.sql, p), t : DBool, n : false };
+			case OpGte:
+				return buildCmp(">=", e1, e2, p);
+			case OpLte:
+				return buildCmp("<=", e1, e2, p);
+			case OpGt:
+				return buildCmp(">", e1, e2, p);
+			case OpLt:
+				return buildCmp("<", e1, e2, p);
+			case OpSub:
+				return buildNum("-", e1, e2, p);
+			case OpDiv:
+				var r = buildNum("/", e1, e2, p);
+				r.t = DFloat;
+				return r;
+			case OpMult:
+				return buildNum("*", e1, e2, p);
+			case OpEq, OpNotEq:
+				return buildEq(op == OpEq, e1, e2, p);
+			case OpXor:
+				return buildInt("^", e1, e2, p);
+			case OpOr:
+				return buildInt("|", e1, e2, p);
+			case OpAnd:
+				return buildInt("&", e1, e2, p);
+			case OpShr:
+				return buildInt(">>", e1, e2, p);
+			case OpShl:
+				return buildInt("<<", e1, e2, p);
+			case OpMod:
+				return buildNum("%", e1, e2, p);
+			case OpUShr, OpInterval, OpAssignOp(_), OpAssign:
+				error("Unsupported operation", p);
+			}
+		case EUnop(op, post, e):
+			var r = buildCond(e);
+			switch( op ) {
+			case OpNot:
+				var sql = makeString("!", p);
+				unify(r.t, DBool, e.pos);
+				return { sql : sqlAdd(sql, r.sql, p), t : DBool, n : r.n };
+			case OpNegBits:
+				var sql = makeString("~", p);
+				unify(r.t, DInt, e.pos);
+				return { sql : sqlAdd(sql, r.sql, p), t : DInt, n : r.n };
+			case OpNeg:
+				var sql = makeString("-", p);
+				unify(r.t, DFloat, e.pos);
+				return { sql : sqlAdd(sql, r.sql, p), t : r.t, n : r.n };
+			case OpIncrement, OpDecrement:
+				error("Unsupported operation", p);
+			}
+		case EConst(c):
+			switch( c ) {
+			case CInt(s): return { sql : makeString(s, p), t : DInt, n : false };
+			case CFloat(s): return { sql : makeString(s, p), t : DFloat, n : false };
+			case CString(s): return { sql : if( ~/^[A-Za-z0-9 ]$/.match(s) ) makeString("'" + s + "'", p) else sqlQuoteValue(cond, DText), t : DString(s.length), n : false };
+			case CRegexp(_): error("Unsupported", p);
+			case CIdent(n), CType(n):
+				var f = current.hfields.get(n);
+				if( f != null ) {
+					if( (try Context.typeof(cond) catch( e : Dynamic ) null) != null )
+						error("Possible conflict between variable and database field", p);
+					return { sql : makeString(n, p), t : f.t, n : f.isNull };
+				}
+				if( n == "null" )
+					return { sql : makeString("NULL", p), t : DNull, n : true };
+				return buildDefault(cond);
+			}
+		case ECall(c, pl):
+			switch( c.expr ) {
+			case EConst(co):
+				switch(co) {
+				case CIdent(t), CType(t):
+					var f = functions.get(t);
+					if( f == null ) error("Unknown method " + t, c.pos);
+					if( f.params.length != pl.length ) error("Function " + f.name + " requires " + f.params.length + " parameters", p);
+					var parts = f.sql.split("$");
+					var sql = makeString(parts[0], p);
+					var first = true;
+					var isNull = false;
+					for( i in 0...f.params.length ) {
+						var r = buildCond(pl[i]);
+						if( r.n ) isNull = true;
+						unify(r.t, f.params[i], pl[i].pos);
+						if( first )
+							first = false;
+						else
+							sql = sqlAddString(sql, ",");
+						sql = sqlAdd(sql, r.sql, p);
+					}
+					sql = sqlAddString(sql, parts[1]);
+					// assume that for all SQL functions, a NULL parameter will make a NULL result
+					return { sql : sql, t : f.ret, n : isNull };
+				default:
+				}
+			case EField(e, f), EType(e, f):
+				switch( f ) {
+				case "like":
+					if( pl.length == 1 ) {
+						var r = buildCond(e);
+						var v = buildCond(pl[0]);
+						unify(r.t, DText, e.pos);
+						unify(v.t, DText, pl[0].pos);
+						return { sql : makeOp(" LIKE ", r.sql, v.sql, p), t : DBool, n : r.n || v.n };
+					}
+				}
+			default:
+			}
+		case EField(_, _), EType(_, _):
+			return buildDefault(cond);
+		default:
+		}
+		error("Unsupported expression", p);
+		return null;
+	}
+	
+	function buildSingleCond( inf : SpodInfos, sql : Expr, cond : Expr ) {
+		switch( cond.expr ) {
+		case EObjectDecl(fl):
+			var first = true;
+			var key = inf.key.copy();
+			for( f in fl ) {
+				var fi = inf.hfields.get(f.field);
+				if( fi == null ) error("No database field " + f.field, cond.pos);
+				if( first )
+					first = false;
+				else
+					sql = sqlAddString(sql, " AND ");
+				sql = sqlAddString(sql, quoteField(fi.name) + " = ");
+				sql = sqlAddValue(sql, f.expr, fi.t);
+				key.remove(fi.name);
+			}
+			if( key.length > 0 )
+				error("Missing key '" + key[0] + "'", cond.pos);
+		default:
+			if( inf.key.length > 1 )
+				error("You can't use a single value on a table with multiple keys (" + inf.key.join(",") + ")", cond.pos);
+			sql = sqlAddString(sql, quoteField(inf.key[0]) + " = ");
+			sql = sqlAddValue(sql, cond, inf.hfields.get(inf.key[0]).t);
+		}
+		return sql;
+	}
+	
+	public static function getInfos( t : haxe.macro.Type ) {
+		var c = switch( t ) {
+		case TInst(c, _): if( c.toString() == "neko.db.Object" ) return null; c;
+		default: return null;
+		};
+		var i = inst;
+		if( i == null ) {
+			i = new SpodData();
+			inst = i;
+		}
+		return i.getSpodInfos(c);
+	}
+
+	
+	#if macro
+	static var RTTI = false;
+	
+	public static function addRtti() {
+		var eret = { expr : EBlock([]), pos : Context.currentPos() };
+		if( RTTI ) return eret;
+		RTTI = true;
+		Context.getType("neko.db.SpodInfos");
+		Context.onGenerate(function(types) {
+			for( t in types )
+				switch( t ) {
+				case TInst(c, _):
+					var c = c.get();
+					var cur = c.superClass;
+					while( cur != null ) {
+						if( cur.t.toString() == "neko.db.Object" )
+							break;
+						cur = cur.t.get().superClass;
+					}
+					if( cur == null || c.meta.has(":skip") )
+						continue;
+					var inf = getInfos(t);
+					var s = new haxe.Serializer();
+					s.useEnumIndex = true;
+					s.useCache = true;
+					s.serialize(inf);
+					c.meta.add("rtti", [ { expr : EConst(CString(s.toString())), pos : c.pos } ], c.pos);
+				default:
+				}
+		});
+		return eret;
+	}
+	
+	static function getManagerInfos( t : haxe.macro.Type ) {
+		var param = null;
+		switch( t ) {
+		case TInst(c, p):
+			while( true ) {
+				if( c.toString() == "neko.db.MacroManager" ) {
+					param = p[0];
+					break;
+				}
+				var csup = c.get().superClass;
+				if( csup == null ) break;
+				c = csup.t;
+				p = csup.params;
+			}
+		case TType(t, p):
+			if( p.length == 1 && t.toString() == "neko.db.Manager" )
+				param = p[0];
+		default:
+		}
+		var inf = if( param == null ) null else getInfos(param);
+		if( inf == null )
+			Context.error("This method must be called from a specific Manager", Context.currentPos());
+		return inf;
+	}
+	
+	static function buildSQL( em : Expr, econd : Expr, prefix : String, ?single : Bool ) {
+		var pos = Context.currentPos();
+		var inf = getManagerInfos(Context.typeof(em));
+		var sql = { expr : EConst(CString(prefix + " " + inst.quoteField(inf.name) + " WHERE ")), pos : econd.pos };
+		inst.current = inf;
+		inst.initManager(pos);
+		if( single )
+			return inst.buildSingleCond(inf, sql, econd);
+		var r = try inst.buildCond(econd) catch( e : BuildError ) switch( e ) { case EExpr(e): return e; };
+		if( r.t != DBool ) Context.error("Expression should be a condition", econd.pos);
+		return inst.sqlAdd(sql, r.sql, sql.pos);
+	}
+	
+	public static function macroGet( em : Expr, econd : Expr, elock : Expr ) {
+		var sql = buildSQL(em, econd, "SELECT * FROM", true);
+		var pos = Context.currentPos();
+		return { expr : ECall({ expr : EField(em,"unsafeObject"), pos : pos },[sql,elock]), pos : pos };
+	}
+	
+	public static function macroSearch( em : Expr, econd : Expr, elock : Expr, ?single ) {
+		var sql = buildSQL(em, econd, "SELECT * FROM");
+		var pos = Context.currentPos();
+		var e = { expr : ECall( { expr : EField(em, "unsafeObjects"), pos : pos }, [sql,elock]), pos : pos };
+		if( single )
+			e = { expr : ECall( { expr : EField(e, "first"), pos : pos }, []), pos : pos };
+		return e;
+	}
+
+	public static function macroCount( em : Expr, econd : Expr ) {
+		var sql = buildSQL(em, econd, "SELECT COUNT(*) FROM");
+		var pos = Context.currentPos();
+		return { expr : ECall({ expr : EField(em,"unsafeCount"), pos : pos },[sql]), pos : pos };
+	}
+	
+	public static function macroDelete( em : Expr, econd : Expr ) {
+		var sql = buildSQL(em, econd, "DELETE FROM");
+		var pos = Context.currentPos();
+		return { expr : ECall({ expr : EField(em,"unsafeDelete"), pos : pos },[sql]), pos : pos };
+	}
+	
+	#end
+
+}

std/neko/db/SpodInfos.hx

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2005-2011, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package neko.db;
+
+enum SpodType {
+	DId;
+	DInt;
+	DUId;
+	DUInt;
+	DBigId;
+	DBigInt;
+	DSingle;
+	DFloat;
+	DBool;
+	DString( n : Int );
+	DDate;
+	DDateTime;
+	DTinyText;
+	DSmallText;
+	DText;
+	DSmallBinary;
+	DLongBinary;
+	DBinary;
+	DBytes( n : Int );
+	DEncoded;
+	DSerialized;
+	DNekoSerialized;
+	DFlags( flags : Array<String> );
+	// specific for intermediate calculus
+	DInterval;
+	DNull;
+}
+
+typedef SpodField = {
+	var name : String;
+	var t : SpodType;
+	var isNull : Bool;
+}
+
+typedef SpodRelation = {
+	var prop : String;
+	var key : String;
+	var type : String;
+	var cascade : Bool;
+	var lock : Bool;
+	var isNull : Bool;
+}
+
+typedef SpodInfos = {
+	var name : String;
+	var key : Array<String>;
+	var fields : Array<SpodField>;
+	var hfields : Hash<SpodField>;
+	var relations : Array<SpodRelation>;
+	var indexes : Array<{ keys : Array<String>, unique : Bool }>;
+}

std/neko/db/Types.hx

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2005-2011, The haXe Project Contributors
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   - Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+package neko.db;
+
+// basic types
+typedef SId = Int
+typedef SInt = Int
+typedef SUId = Int
+typedef SUInt = Int
+typedef SBigId = Float
+typedef SBigInt = Float
+typedef SSingle = Float
+typedef SFloat = Float
+typedef SBool = Bool
+typedef SString<Const> = String
+typedef SDate = Date
+typedef SDateTime = Date
+typedef STinyText = String
+typedef SSmallText = String
+typedef SText = String
+typedef SSmallBinary = String
+typedef SLongBinary = String
+typedef SBinary = String
+typedef SBytes<Const> = String
+
+// extra
+typedef SNull<T> = T
+typedef SEncoded = Int
+typedef SSerialized = String
+typedef SNekoSerialized = String
+
+extern class SFlags<T> {
+	public inline function get( v : T ) : Bool {
+		return (cast this) & (1 << Type.enumIndex(v)) != 0;
+	}
+	public inline function set( v : T ) : Void {
+		untyped this |= 1 << Type.enumIndex(v);
+	}
+	public inline function unset( v : T ) : Void {
+		untyped this &= 0xFFFFFFF - (1 << Type.enumIndex(v));
+	}
+}