SpodMacros.hx 35 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149
  1. /*
  2. * Copyright (c) 2005-2011, The haXe Project Contributors
  3. * All rights reserved.
  4. * Redistribution and use in source and binary forms, with or without
  5. * modification, are permitted provided that the following conditions are met:
  6. *
  7. * - Redistributions of source code must retain the above copyright
  8. * notice, this list of conditions and the following disclaimer.
  9. * - Redistributions in binary form must reproduce the above copyright
  10. * notice, this list of conditions and the following disclaimer in the
  11. * documentation and/or other materials provided with the distribution.
  12. *
  13. * THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
  14. * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  15. * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  16. * DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
  17. * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  19. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  20. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  23. * DAMAGE.
  24. */
  25. package sys.db;
  26. import sys.db.SpodInfos;
  27. import haxe.macro.Expr;
  28. import haxe.macro.Type.VarAccess;
  29. #if macro
  30. import haxe.macro.Context;
  31. #end
  32. private typedef SqlFunction = {
  33. var name : String;
  34. var params : Array<SpodType>;
  35. var ret : SpodType;
  36. var sql : String;
  37. }
  38. class SpodMacros {
  39. static var GLOBAL = null;
  40. static var simpleString = ~/^[A-Za-z0-9 ]*$/;
  41. var isNull : Bool;
  42. var manager : Expr;
  43. var inf : SpodInfos;
  44. var g : {
  45. var cache : Hash<SpodInfos>;
  46. var types : Hash<SpodType>;
  47. var functions : Hash<SqlFunction>;
  48. };
  49. function new(c) {
  50. if( GLOBAL != null )
  51. g = GLOBAL;
  52. else {
  53. g = initGlobals();
  54. GLOBAL = g;
  55. }
  56. inf = getSpodInfos(c);
  57. }
  58. function initGlobals()
  59. {
  60. var cache = new Hash();
  61. var types = new Hash();
  62. for( c in Type.getEnumConstructs(SpodType) ) {
  63. var e : Dynamic = Reflect.field(SpodType, c);
  64. if( Std.is(e, SpodType) )
  65. types.set("S"+c.substr(1), e);
  66. }
  67. types.remove("SNull");
  68. var functions = new Hash();
  69. for( f in [
  70. { name : "now", params : [], ret : DDateTime, sql : "NOW($)" },
  71. { name : "curDate", params : [], ret : DDate, sql : "CURDATE($)" },
  72. { name : "seconds", params : [DFloat], ret : DInterval, sql : "INTERVAL $ SECOND" },
  73. { name : "minutes", params : [DFloat], ret : DInterval, sql : "INTERVAL $ MINUTE" },
  74. { name : "hours", params : [DFloat], ret : DInterval, sql : "INTERVAL $ HOUR" },
  75. { name : "days", params : [DFloat], ret : DInterval, sql : "INTERVAL $ DAY" },
  76. { name : "months", params : [DFloat], ret : DInterval, sql : "INTERVAL $ MONTH" },
  77. { name : "years", params : [DFloat], ret : DInterval, sql : "INTERVAL $ YEAR" },
  78. { name : "date", params : [DDateTime], ret : DDate, sql : "DATE($)" },
  79. ])
  80. functions.set(f.name, f);
  81. return { cache : cache, types : types, functions : functions };
  82. }
  83. public dynamic function error( msg : String, pos : Position ) : Dynamic {
  84. #if macro
  85. Context.error(msg, pos);
  86. #else
  87. throw msg;
  88. #end
  89. return null;
  90. }
  91. public dynamic function typeof( e : Expr ) : haxe.macro.Type {
  92. #if macro
  93. return Context.typeof(e);
  94. #else
  95. throw "not implemented";
  96. return null;
  97. #end
  98. }
  99. public dynamic function follow( t : haxe.macro.Type ) : haxe.macro.Type {
  100. #if macro
  101. return Context.follow(t);
  102. #else
  103. throw "not implemented";
  104. return null;
  105. #end
  106. }
  107. public dynamic function getManager( t : haxe.macro.Type, p : Position ) : SpodMacros {
  108. #if macro
  109. return getManagerInfos(t, p);
  110. #else
  111. throw "not implemented";
  112. return null;
  113. #end
  114. }
  115. function makeInt( t : haxe.macro.Type ) {
  116. switch( t ) {
  117. case TInst(c, _):
  118. var name = c.toString();
  119. if( name.charAt(0) == "I" )
  120. return Std.parseInt(name.substr(1));
  121. default:
  122. }
  123. throw "Unsupported " + Std.string(t);
  124. }
  125. function makeSpod( t : haxe.macro.Type ) {
  126. switch( t ) {
  127. case TInst(c, p):
  128. var name = c.toString();
  129. var cl = c.get();
  130. if( cl.superClass != null && cl.superClass.t.toString() == "sys.db.Object" )
  131. return name;
  132. case TType(t, p):
  133. var name = t.toString();
  134. if( p.length == 1 && (name == "Null" || name == "sys.db.SNull") ) {
  135. isNull = true;
  136. return makeSpod(p[0]);
  137. }
  138. default:
  139. }
  140. return null;
  141. }
  142. function makeType( t : haxe.macro.Type ) {
  143. switch( t ) {
  144. case TInst(c, p):
  145. var name = c.toString();
  146. return switch( name ) {
  147. case "Int": DInt;
  148. case "Float": DFloat;
  149. case "String": DText;
  150. case "Date": DDateTime;
  151. case "haxe.io.Bytes": DBinary;
  152. case "sys.db.SFlags":
  153. switch( p[0] ) {
  154. case TEnum(e,_):
  155. var cl = e.get().names;
  156. if( cl.length > 1 ) {
  157. var prefix = cl[0];
  158. for( c in cl )
  159. while( prefix.length > 0 && c.substr(0, prefix.length) != prefix )
  160. prefix = prefix.substr(0, -1);
  161. for( i in 0...cl.length )
  162. cl[i] = cl[i].substr(prefix.length);
  163. }
  164. return DFlags(cl);
  165. default:
  166. throw "Flags parameter should be an enum";
  167. }
  168. default: throw "Unsupported " + name;
  169. }
  170. case TEnum(e, p):
  171. var name = e.toString();
  172. return switch( name ) {
  173. case "Bool": DBool;
  174. default: throw "Unsupported " + name;
  175. }
  176. case TType(t, p):
  177. var name = t.toString();
  178. if( StringTools.startsWith(name, "sys.db.") )
  179. name = name.substr(7);
  180. var k = g.types.get(name);
  181. if( k != null ) return k;
  182. if( p.length == 1 )
  183. switch( name ) {
  184. case "SString": return DString(makeInt(p[0]));
  185. case "SBytes": return DBytes(makeInt(p[0]));
  186. case "SNull", "Null": isNull = true; return makeType(p[0]);
  187. default:
  188. }
  189. throw "Unsupported " + name;
  190. default:
  191. }
  192. throw "Unsupported " + Std.string(t);
  193. }
  194. function makeIdent( e : Expr ) {
  195. return switch( e.expr ) {
  196. case EConst(c):
  197. switch( c ) {
  198. case CIdent(s), CType(s): s;
  199. default: error("Identifier expected", e.pos);
  200. }
  201. default: error("Identifier expected", e.pos);
  202. }
  203. }
  204. function getSpodInfos( c : haxe.macro.Type.Ref<haxe.macro.Type.ClassType> ) : SpodInfos {
  205. var cname = c.toString();
  206. var i = g.cache.get(cname);
  207. if( i != null ) return i;
  208. i = {
  209. key : null,
  210. name : cname.split(".").pop(), // remove package name
  211. fields : [],
  212. hfields : new Hash(),
  213. relations : [],
  214. indexes : [],
  215. };
  216. var c = c.get();
  217. var fieldsPos = new Hash();
  218. for( f in c.fields.get() ) {
  219. fieldsPos.set(f.name, f.pos);
  220. switch( f.kind ) {
  221. case FMethod(_):
  222. // skip methods
  223. continue;
  224. case FVar(g, s):
  225. // skip not-db fields
  226. if( f.meta.has(":skip") )
  227. continue;
  228. // handle relations
  229. if( f.meta.has(":relation") ) {
  230. if( !Type.enumEq(g,AccCall("get_" + f.name)) || !Type.enumEq(s,AccCall("set_" + f.name)) )
  231. error("Relation should be (dynamic,dynamic)", f.pos);
  232. for( m in f.meta.get() ) {
  233. if( m.name != ":relation" ) continue;
  234. if( m.params.length == 0 ) error("Missing relation key", m.pos);
  235. var params = [];
  236. for( p in m.params )
  237. params.push({ i : makeIdent(p), p : p.pos });
  238. isNull = false;
  239. var t = makeSpod(f.type);
  240. if( t == null ) error("Relation type should be a sys.db.Object", f.pos);
  241. var r = {
  242. prop : f.name,
  243. key : params.shift().i,
  244. type : t,
  245. cascade : false,
  246. lock : false,
  247. isNull : isNull,
  248. };
  249. // setup flags
  250. for( p in params )
  251. switch( p.i ) {
  252. case "lock": r.lock = true;
  253. case "cascade": r.cascade = true;
  254. default: error("Unknown relation flag", p.p);
  255. }
  256. i.relations.push(r);
  257. }
  258. continue;
  259. }
  260. switch( g ) {
  261. case AccCall(_):
  262. error("Relation should be defined with @:relation(key)", f.pos);
  263. default:
  264. }
  265. }
  266. isNull = false;
  267. var fi = {
  268. name : f.name,
  269. t : try makeType(f.type) catch( e : String ) error(e,f.pos),
  270. isNull : isNull,
  271. };
  272. var isId = switch( fi.t ) {
  273. case DId, DUId: true;
  274. default: fi.name == "id";
  275. }
  276. if( isId ) {
  277. if( i.key == null ) i.key = [fi.name] else error("Multiple table id declaration", f.pos);
  278. }
  279. i.fields.push(fi);
  280. i.hfields.set(fi.name, fi);
  281. }
  282. // create fields for undeclared relations keys :
  283. for( r in i.relations ) {
  284. var f = i.hfields.get(r.key);
  285. if( f == null ) {
  286. f = {
  287. name : r.key,
  288. t : DInt,
  289. isNull : r.isNull,
  290. };
  291. i.fields.push(f);
  292. i.hfields.set(f.name, f);
  293. } else {
  294. var pos = fieldsPos.get(f.name);
  295. if( f.t != DInt ) error("Relation key should be SInt", pos);
  296. if( f.isNull != r.isNull ) error("Relation and field should have same nullability", pos);
  297. }
  298. }
  299. // process class metadata
  300. for( m in c.meta.get() )
  301. switch( m.name ) {
  302. case ":id":
  303. i.key = [];
  304. for( p in m.params ) {
  305. var id = makeIdent(p);
  306. if( !i.hfields.exists(id) )
  307. error("This field does not exists", p.pos);
  308. i.key.push(id);
  309. }
  310. if( i.key.length == 0 ) error("Invalid :id", m.pos);
  311. case ":index":
  312. var idx = [];
  313. for( p in m.params ) idx.push(makeIdent(p));
  314. var unique = idx[idx.length - 1] == "unique";
  315. if( unique ) idx.pop();
  316. if( idx.length == 0 ) error("Invalid :index", m.pos);
  317. for( k in 0...idx.length )
  318. if( !i.hfields.exists(idx[k]) )
  319. error("This field does not exists", m.params[k].pos);
  320. i.indexes.push( { keys : idx, unique : unique } );
  321. case ":table":
  322. if( m.params.length != 1 ) error("Invalid :table", m.pos);
  323. i.name = switch( m.params[0].expr ) {
  324. case EConst(c): switch( c ) { case CString(s): s; default: null; }
  325. default: null;
  326. };
  327. if( i.name == null ) error("Invalid :table value", m.params[0].pos);
  328. default:
  329. }
  330. // check primary key defined
  331. if( i.key == null )
  332. error("Table is missing unique id, use either SId or @:id", c.pos);
  333. g.cache.set(cname, i);
  334. return i;
  335. }
  336. function quoteField( f : String ) {
  337. var m : { private var KEYWORDS : Hash<Bool>; } = Manager;
  338. return m.KEYWORDS.exists(f.toLowerCase()) ? "`"+f+"`" : f;
  339. }
  340. function initManager( pos : Position ) {
  341. manager = { expr : EType({ expr : EField({ expr : EConst(CIdent("sys")), pos : pos },"db"), pos : pos }, "Manager"), pos : pos };
  342. }
  343. inline function makeString( s : String, pos ) {
  344. return { expr : EConst(CString(s)), pos : pos };
  345. }
  346. inline function makeOp( op : String, e1, e2, pos ) {
  347. return sqlAdd(sqlAddString(e1,op),e2,pos);
  348. }
  349. inline function sqlAdd( e1 : Expr, e2 : Expr, pos : Position ) {
  350. return { expr : EBinop(OpAdd, e1, e2), pos : pos };
  351. }
  352. inline function sqlAddString( sql : Expr, s : String ) {
  353. return { expr : EBinop(OpAdd, sql, makeString(s,sql.pos)), pos : sql.pos };
  354. }
  355. function sqlQuoteValue( v : Expr, t : SpodType ) {
  356. switch( v.expr ) {
  357. case EConst(c):
  358. switch( c ) {
  359. case CInt(_), CFloat(_): return v;
  360. case CString(s):
  361. if( simpleString.match(s) ) return { expr : EConst(CString("'"+s+"'")), pos : v.pos };
  362. case CIdent(n):
  363. switch( n ) {
  364. case "null": return { expr : EConst(CString("NULL")), pos : v.pos };
  365. case "true": return { expr : EConst(CInt("1")), pos : v.pos };
  366. case "false": return { expr : EConst(CInt("0")), pos : v.pos };
  367. }
  368. default:
  369. }
  370. default:
  371. }
  372. return { expr : ECall( { expr : EField(manager, "quoteAny"), pos : v.pos }, [ensureType(v,t)]), pos : v.pos }
  373. }
  374. inline function sqlAddValue( sql : Expr, v : Expr, t : SpodType ) {
  375. return { expr : EBinop(OpAdd, sql, sqlQuoteValue(v,t)), pos : sql.pos };
  376. }
  377. function unifyClass( t : SpodType ) {
  378. return switch( t ) {
  379. case DId, DInt, DUId, DUInt, DEncoded, DFlags(_), DTinyInt: 0;
  380. case DBigId, DBigInt, DSingle, DFloat: 1;
  381. case DBool: 2;
  382. case DString(_), DTinyText, DSmallText, DText, DSerialized: 3;
  383. case DDate, DDateTime, DTimeStamp: 4;
  384. case DSmallBinary, DLongBinary, DBinary, DBytes(_), DNekoSerialized: 5;
  385. case DInterval: 6;
  386. case DNull: 7;
  387. };
  388. }
  389. function tryUnify( t, rt ) {
  390. if( t == rt ) return true;
  391. var c = unifyClass(t);
  392. var rc = unifyClass(rt);
  393. return c == rc || (c == 0 && rc == 1); // allow Int-to-Float expansion
  394. }
  395. function typeStr( t : SpodType ) {
  396. return Std.string(t).substr(1);
  397. }
  398. function canStringify( t : SpodType ) {
  399. return switch( unifyClass(t) ) {
  400. case 0, 1, 2, 3, 4, 5, 7: true;
  401. default: false;
  402. };
  403. }
  404. function convertType( t : SpodType ) {
  405. var pack = [];
  406. return TPath( {
  407. name : switch( unifyClass(t) ) {
  408. case 0: "Int";
  409. case 1: "Float";
  410. case 2: "Bool";
  411. case 3: "String";
  412. case 4: "Date";
  413. case 5: pack = ["haxe", "io"]; "Bytes";
  414. default: throw "assert";
  415. },
  416. pack : pack,
  417. params : [],
  418. sub : null,
  419. });
  420. }
  421. function unify( t : SpodType, rt : SpodType, pos : Position ) {
  422. if( !tryUnify(t, rt) )
  423. error(typeStr(t) + " should be " + typeStr(rt), pos);
  424. }
  425. function buildCmp( op, e1, e2, pos ) {
  426. var r1 = buildCond(e1);
  427. var r2 = buildCond(e2);
  428. unify(r2.t, r1.t, e2.pos);
  429. if( !tryUnify(r1.t, DInt) && !tryUnify(r1.t, DDate) && !tryUnify(r1.t, DText) )
  430. unify(r1.t, DInt, e1.pos);
  431. return { sql : makeOp(op, r1.sql, r2.sql, pos), t : DBool, n : r1.n || r2.n };
  432. }
  433. function buildNum( op, e1, e2, pos ) {
  434. var r1 = buildCond(e1);
  435. var r2 = buildCond(e2);
  436. var c1 = unifyClass(r1.t);
  437. var c2 = unifyClass(r2.t);
  438. if( c1 > 1 ) {
  439. if( op == "-" && tryUnify(r1.t, DDateTime) && tryUnify(r2.t,DInterval) )
  440. return { sql : makeOp(op, r1.sql, r2.sql, pos), t : DDateTime, n : r1.n };
  441. unify(r1.t, DInt, e1.pos);
  442. }
  443. if( c2 > 1 ) unify(r2.t, DInt, e2.pos);
  444. return { sql : makeOp(op, r1.sql, r2.sql, pos), t : (c1 + c2) == 0 ? DInt : DFloat, n : r1.n || r2.n };
  445. }
  446. function buildInt( op, e1, e2, pos ) {
  447. var r1 = buildCond(e1);
  448. var r2 = buildCond(e2);
  449. unify(r1.t, DInt, e1.pos);
  450. unify(r2.t, DInt, e2.pos);
  451. return { sql : makeOp(op, r1.sql, r2.sql, pos), t : DInt, n : r1.n || r2.n };
  452. }
  453. function buildEq( eq, e1 : Expr, e2, pos ) {
  454. var r1 = null;
  455. switch( e1.expr ) {
  456. case EConst(c):
  457. switch( c ) {
  458. case CIdent(i):
  459. if( i.charCodeAt(0) == "$".code ) {
  460. var tmp = { field : i.substr(1), expr : e2 };
  461. var f = getField(tmp);
  462. r1 = { sql : makeString(quoteField(tmp.field), e1.pos), t : f.t, n : f.isNull };
  463. e2 = tmp.expr;
  464. }
  465. default:
  466. }
  467. default:
  468. }
  469. if( r1 == null )
  470. r1 = buildCond(e1);
  471. var r2 = buildCond(e2);
  472. if( r2.t == DNull ) {
  473. if( !r1.n )
  474. error("Expression can't be null", e1.pos);
  475. return { sql : sqlAddString(r1.sql, eq ? " IS NULL" : " IS NOT NULL"), t : DBool, n : false };
  476. } else {
  477. unify(r2.t, r1.t, e2.pos);
  478. unify(r1.t, r2.t, e1.pos);
  479. }
  480. var sql;
  481. // use some different operators if there is a possibility for comparing two NULLs
  482. if( r1.n || r2.n ) {
  483. sql = makeOp(" <=> ", r1.sql, r2.sql, pos);
  484. if( !eq )
  485. sql = sqlAdd(makeString("NOT(", pos), sqlAddString(sql, ")"), pos);
  486. } else
  487. sql = makeOp(eq?" = ":" != ", r1.sql, r2.sql, pos);
  488. return { sql : sql, t : DBool, n : r1.n || r2.n };
  489. }
  490. function buildDefault( cond : Expr ) {
  491. var t = typeof(cond);
  492. isNull = false;
  493. var d = try makeType(t) catch( e : String ) try makeType(follow(t)) catch( e : String ) error("Unsupported type " + Std.string(t), cond.pos);
  494. return { sql : sqlQuoteValue(cond, d), t : d, n : isNull };
  495. }
  496. function getField( f : { field : String, expr : Expr } ) {
  497. var fi = inf.hfields.get(f.field);
  498. if( fi == null ) {
  499. for( r in inf.relations )
  500. if( r.prop == f.field ) {
  501. var path = r.type.split(".");
  502. var p = f.expr.pos;
  503. path.push("manager");
  504. var first = path.shift();
  505. var mpath = { expr : EConst(first.charCodeAt(0) <= 'Z'.code ? CType(first) : CIdent(first)), pos : p };
  506. for( e in path )
  507. mpath = { expr : e.charCodeAt(0) <= 'Z'.code ? EType(mpath, e) : EField(mpath, e), pos : p };
  508. var m = getManager(typeof(mpath),p);
  509. var getid = { expr : ECall( { expr : EField(mpath, "unsafeGetId"), pos : p }, [f.expr]), pos : p };
  510. f.field = r.key;
  511. f.expr = ensureType(getid, m.inf.hfields.get(m.inf.key[0]).t);
  512. return inf.hfields.get(r.key);
  513. }
  514. error("No database field '" + f.field+"'", f.expr.pos);
  515. }
  516. return fi;
  517. }
  518. function buildCond( cond : Expr ) {
  519. var sql = null;
  520. var p = cond.pos;
  521. switch( cond.expr ) {
  522. case EObjectDecl(fl):
  523. var first = true;
  524. var sql = makeString("(", p);
  525. var fields = new Hash();
  526. for( f in fl ) {
  527. var fi = getField(f);
  528. if( first )
  529. first = false;
  530. else
  531. sql = sqlAddString(sql, " AND ");
  532. sql = sqlAddString(sql, quoteField(fi.name) + (fi.isNull ? " <=> " : " = "));
  533. sql = sqlAddValue(sql, f.expr, fi.t);
  534. if( fields.exists(fi.name) )
  535. error("Duplicate field " + fi.name, p);
  536. else
  537. fields.set(fi.name, true);
  538. }
  539. if( first ) sqlAddString(sql, "TRUE");
  540. sql = sqlAddString(sql, ")");
  541. return { sql : sql, t : DBool, n : false };
  542. case EParenthesis(e):
  543. var r = buildCond(e);
  544. r.sql = sqlAdd(makeString("(", p), r.sql, p);
  545. r.sql = sqlAddString(r.sql, ")");
  546. return r;
  547. case EBinop(op, e1, e2):
  548. switch( op ) {
  549. case OpAdd:
  550. var r1 = buildCond(e1);
  551. var r2 = buildCond(e2);
  552. var rt = if( tryUnify(r1.t, DFloat) && tryUnify(r2.t, DFloat) )
  553. tryUnify(r1.t, DInt) ? tryUnify(r2.t, DInt) ? DInt : DFloat : DFloat;
  554. else if( (tryUnify(r1.t, DText) && canStringify(r2.t)) || (tryUnify(r2.t, DText) && canStringify(r1.t)) )
  555. return { sql : sqlAddString(sqlAdd(sqlAddString(sqlAdd(makeString("CONCAT(",p),r1.sql,p),","),r2.sql,p),")"), t : DText, n : r1.n || r2.n }
  556. else
  557. error("Can't add " + typeStr(r1.t) + " and " + typeStr(r2.t), p);
  558. return { sql : makeOp("+", r1.sql, r2.sql, p), t : rt, n : r1.n || r2.n };
  559. case OpBoolAnd, OpBoolOr:
  560. var r1 = buildCond(e1);
  561. var r2 = buildCond(e2);
  562. unify(r1.t, DBool, e1.pos);
  563. unify(r2.t, DBool, e2.pos);
  564. return { sql : makeOp(op == OpBoolAnd ? " AND " : " OR ", r1.sql, r2.sql, p), t : DBool, n : false };
  565. case OpGte:
  566. return buildCmp(">=", e1, e2, p);
  567. case OpLte:
  568. return buildCmp("<=", e1, e2, p);
  569. case OpGt:
  570. return buildCmp(">", e1, e2, p);
  571. case OpLt:
  572. return buildCmp("<", e1, e2, p);
  573. case OpSub:
  574. return buildNum("-", e1, e2, p);
  575. case OpDiv:
  576. var r = buildNum("/", e1, e2, p);
  577. r.t = DFloat;
  578. return r;
  579. case OpMult:
  580. return buildNum("*", e1, e2, p);
  581. case OpEq, OpNotEq:
  582. return buildEq(op == OpEq, e1, e2, p);
  583. case OpXor:
  584. return buildInt("^", e1, e2, p);
  585. case OpOr:
  586. return buildInt("|", e1, e2, p);
  587. case OpAnd:
  588. return buildInt("&", e1, e2, p);
  589. case OpShr:
  590. return buildInt(">>", e1, e2, p);
  591. case OpShl:
  592. return buildInt("<<", e1, e2, p);
  593. case OpMod:
  594. return buildNum("%", e1, e2, p);
  595. case OpUShr, OpInterval, OpAssignOp(_), OpAssign:
  596. error("Unsupported operation", p);
  597. }
  598. case EUnop(op, post, e):
  599. var r = buildCond(e);
  600. switch( op ) {
  601. case OpNot:
  602. var sql = makeString("!", p);
  603. unify(r.t, DBool, e.pos);
  604. switch( r.sql.expr ) {
  605. case EConst(_):
  606. default:
  607. r.sql = sqlAddString(r.sql, ")");
  608. sql = sqlAddString(sql, "(");
  609. }
  610. return { sql : sqlAdd(sql, r.sql, p), t : DBool, n : r.n };
  611. case OpNegBits:
  612. var sql = makeString("~", p);
  613. unify(r.t, DInt, e.pos);
  614. return { sql : sqlAdd(sql, r.sql, p), t : DInt, n : r.n };
  615. case OpNeg:
  616. var sql = makeString("-", p);
  617. unify(r.t, DFloat, e.pos);
  618. return { sql : sqlAdd(sql, r.sql, p), t : r.t, n : r.n };
  619. case OpIncrement, OpDecrement:
  620. error("Unsupported operation", p);
  621. }
  622. case EConst(c):
  623. switch( c ) {
  624. case CInt(s): return { sql : makeString(s, p), t : DInt, n : false };
  625. case CFloat(s): return { sql : makeString(s, p), t : DFloat, n : false };
  626. case CString(s): return { sql : sqlQuoteValue(cond, DText), t : DString(s.length), n : false };
  627. case CRegexp(_): error("Unsupported", p);
  628. case CIdent(n), CType(n):
  629. if( n.charCodeAt(0) == "$".code ) {
  630. n = n.substr(1);
  631. var f = inf.hfields.get(n);
  632. if( f == null ) error("Unknown database field '" + n + "'", p);
  633. return { sql : makeString(quoteField(f.name), p), t : f.t, n : f.isNull };
  634. }
  635. switch( n ) {
  636. case "null":
  637. return { sql : makeString("NULL", p), t : DNull, n : true };
  638. case "true":
  639. return { sql : makeString("1", p), t : DBool, n : false };
  640. case "false":
  641. return { sql : makeString("0", p), t : DBool, n : false };
  642. }
  643. return buildDefault(cond);
  644. }
  645. case ECall(c, pl):
  646. switch( c.expr ) {
  647. case EConst(co):
  648. switch(co) {
  649. case CIdent(t), CType(t):
  650. if( t.charCodeAt(0) == '$'.code ) {
  651. var f = g.functions.get(t.substr(1));
  652. if( f == null ) error("Unknown method " + t, c.pos);
  653. if( f.params.length != pl.length ) error("Function " + f.name + " requires " + f.params.length + " parameters", p);
  654. var parts = f.sql.split("$");
  655. var sql = makeString(parts[0], p);
  656. var first = true;
  657. var isNull = false;
  658. for( i in 0...f.params.length ) {
  659. var r = buildCond(pl[i]);
  660. if( r.n ) isNull = true;
  661. unify(r.t, f.params[i], pl[i].pos);
  662. if( first )
  663. first = false;
  664. else
  665. sql = sqlAddString(sql, ",");
  666. sql = sqlAdd(sql, r.sql, p);
  667. }
  668. sql = sqlAddString(sql, parts[1]);
  669. // assume that for all SQL functions, a NULL parameter will make a NULL result
  670. return { sql : sql, t : f.ret, n : isNull };
  671. }
  672. default:
  673. }
  674. case EField(e, f), EType(e, f):
  675. switch( f ) {
  676. case "like":
  677. if( pl.length == 1 ) {
  678. var r = buildCond(e);
  679. var v = buildCond(pl[0]);
  680. if( !tryUnify(r.t, DText) ) {
  681. if( tryUnify(r.t, DBinary) )
  682. unify(v.t, DBinary, pl[0].pos);
  683. else
  684. unify(r.t, DText, e.pos);
  685. } else
  686. unify(v.t, DText, pl[0].pos);
  687. return { sql : makeOp(" LIKE ", r.sql, v.sql, p), t : DBool, n : r.n || v.n };
  688. }
  689. case "has":
  690. if( pl.length == 1 ) {
  691. var r = buildCond(e);
  692. switch( r.t ) {
  693. case DFlags(vals):
  694. var id = makeIdent(pl[0]);
  695. var idx = Lambda.indexOf(vals,id);
  696. if( idx < 0 ) error("Flag should be "+vals.join(","), pl[0].pos);
  697. return { sql : sqlAddString(r.sql, " & " + (1 << idx) + " != 0"), t : DBool, n : r.n };
  698. default:
  699. }
  700. }
  701. }
  702. default:
  703. }
  704. return buildDefault(cond);
  705. case EField(_, _), EType(_, _), EDisplay(_):
  706. return buildDefault(cond);
  707. case EIf(e, e1, e2), ETernary(e, e1, e2):
  708. if( e2 == null ) error("If must have an else statement", p);
  709. var r1 = buildCond(e1);
  710. var r2 = buildCond(e2);
  711. unify(r2.t, r1.t, e2.pos);
  712. unify(r1.t, r2.t, e1.pos);
  713. return { sql : { expr : EIf(e, r1.sql, r2.sql), pos : p }, t : r1.t, n : r1.n || r2.n };
  714. case EIn(e, v):
  715. var e = buildCond(e);
  716. var t = TPath({
  717. pack : [],
  718. name : "Iterable",
  719. params : [TPType(convertType(e.t))],
  720. sub : null,
  721. });
  722. return { sql : { expr : ECall( { expr : EField(manager, "quoteList"), pos : p }, [e.sql, { expr : ECheckType(v,t), pos : p } ]), pos : p }, t : DBool, n : e.n };
  723. default:
  724. return buildDefault(cond);
  725. }
  726. error("Unsupported expression", p);
  727. return null;
  728. }
  729. function ensureType( e : Expr, rt : SpodType ) {
  730. return { expr : ECheckType(e, convertType(rt)), pos : e.pos };
  731. }
  732. function checkKeys( econd : Expr ) {
  733. var p = econd.pos;
  734. switch( econd.expr ) {
  735. case EObjectDecl(fl):
  736. var key = inf.key.copy();
  737. for( f in fl ) {
  738. var fi = getField(f);
  739. if( !key.remove(fi.name) ) {
  740. if( Lambda.has(inf.key, fi.name) )
  741. error("Duplicate field " + fi.name, p);
  742. else
  743. error("Field " + f.field + " is not part of table key (" + inf.key.join(",") + ")", p);
  744. }
  745. f.expr = ensureType(f.expr, fi.t);
  746. }
  747. return econd;
  748. default:
  749. if( inf.key.length > 1 )
  750. error("You can't use a single value on a table with multiple keys (" + inf.key.join(",") + ")", p);
  751. var fi = inf.hfields.get(inf.key[0]);
  752. return ensureType(econd, fi.t);
  753. }
  754. }
  755. function orderField(e) {
  756. switch( e.expr ) {
  757. case EConst(c):
  758. switch( c ) {
  759. case CIdent(t), CType(t):
  760. if( !inf.hfields.exists(t) )
  761. error("Unknown database field", e.pos);
  762. return quoteField(t);
  763. default:
  764. }
  765. case EUnop(op, _, e):
  766. if( op == OpNeg )
  767. return orderField(e) + " DESC";
  768. default:
  769. }
  770. error("Invalid order field", e.pos);
  771. return null;
  772. }
  773. function concatStrings( e : Expr ) {
  774. var inf = { e : null, str : null };
  775. browseStrings(inf, e);
  776. if( inf.str != null ) {
  777. var es = { expr : EConst(CString(inf.str)), pos : e.pos };
  778. if( inf.e == null )
  779. inf.e = es;
  780. else
  781. inf.e = { expr : EBinop(OpAdd, inf.e, es), pos : e.pos };
  782. }
  783. return inf.e;
  784. }
  785. function browseStrings( inf : { e : Expr, str : String }, e : Expr ) {
  786. switch( e.expr ) {
  787. case EConst(c):
  788. switch( c ) {
  789. case CString(s):
  790. if( inf.str == null )
  791. inf.str = s;
  792. else
  793. inf.str += s;
  794. return;
  795. case CInt(s), CFloat(s):
  796. if( inf.str != null ) {
  797. inf.str += s;
  798. return;
  799. }
  800. default:
  801. }
  802. case EBinop(op, e1, e2):
  803. if( op == OpAdd ) {
  804. browseStrings(inf,e1);
  805. browseStrings(inf,e2);
  806. return;
  807. }
  808. case EIf(cond, e1, e2):
  809. e = { expr : EIf(cond, concatStrings(e1), concatStrings(e2)), pos : e.pos };
  810. default:
  811. }
  812. if( inf.str != null ) {
  813. e = { expr : EBinop(OpAdd, { expr : EConst(CString(inf.str)), pos : e.pos }, e), pos : e.pos };
  814. inf.str = null;
  815. }
  816. if( inf.e == null )
  817. inf.e = e;
  818. else
  819. inf.e = { expr : EBinop(OpAdd, inf.e, e), pos : e.pos };
  820. }
  821. function buildOptions( eopt : Expr ) {
  822. var p = eopt.pos;
  823. var opts = new Hash();
  824. var opt = { limit : null, orderBy : null, forceIndex : null };
  825. switch( eopt.expr ) {
  826. case EObjectDecl(fields):
  827. var limit = null;
  828. for( o in fields ) {
  829. if( opts.exists(o.field) ) error("Duplicate option " + o.field, p);
  830. opts.set(o.field, true);
  831. switch( o.field ) {
  832. case "orderBy":
  833. var fields = switch( o.expr.expr ) {
  834. case EArrayDecl(vl): Lambda.array(Lambda.map(vl, orderField));
  835. case ECall(v, pl):
  836. if( pl.length != 0 || !Type.enumEq(v.expr, EConst(CIdent("rand"))) )
  837. [orderField(o.expr)]
  838. else
  839. ["RAND()"];
  840. default: [orderField(o.expr)];
  841. };
  842. opt.orderBy = fields.join(",");
  843. case "limit":
  844. var limits = switch( o.expr.expr ) {
  845. case EArrayDecl(vl): Lambda.array(Lambda.map(vl, buildDefault));
  846. default: [buildDefault(o.expr)];
  847. }
  848. if( limits.length == 0 || limits.length > 2 ) error("Invalid limits", o.expr.pos);
  849. var l0 = limits[0], l1 = limits[1];
  850. unify(l0.t, DInt, l0.sql.pos);
  851. if( l1 != null )
  852. unify(l1.t, DInt, l1.sql.pos);
  853. opt.limit = { pos : l0.sql, len : l1 == null ? null : l1.sql };
  854. case "forceIndex":
  855. var fields = switch( o.expr.expr ) {
  856. case EArrayDecl(vl): Lambda.array(Lambda.map(vl, makeIdent));
  857. default: [makeIdent(o.expr)];
  858. }
  859. for( f in fields )
  860. if( !inf.hfields.exists(f) )
  861. error("Unknown field " + f, o.expr.pos);
  862. var idx = fields.join(",");
  863. if( !Lambda.exists(inf.indexes, function(i) return i.keys.join(",") == idx) && !Lambda.exists(inf.relations,function(r) return r.key == idx) )
  864. error("These fields are not indexed", o.expr.pos);
  865. opt.forceIndex = idx;
  866. default:
  867. error("Unknown option '" + o.field + "'", p);
  868. }
  869. }
  870. default:
  871. error("Options should be { orderBy : field, limit : [a,b] }", p);
  872. }
  873. return opt;
  874. }
  875. public static function getInfos( t : haxe.macro.Type ) {
  876. var c = switch( t ) {
  877. case TInst(c, _): if( c.toString() == "sys.db.Object" ) return null; c;
  878. default: return null;
  879. };
  880. return new SpodMacros(c);
  881. }
  882. #if macro
  883. static var RTTI = false;
  884. public static function addRtti() : Array<Field> {
  885. if( RTTI ) return null;
  886. RTTI = true;
  887. Context.getType("sys.db.SpodInfos");
  888. Context.onGenerate(function(types) {
  889. for( t in types )
  890. switch( t ) {
  891. case TInst(c, _):
  892. var c = c.get();
  893. var cur = c.superClass;
  894. while( cur != null ) {
  895. if( cur.t.toString() == "sys.db.Object" )
  896. break;
  897. cur = cur.t.get().superClass;
  898. }
  899. if( cur == null || c.meta.has(":skip") )
  900. continue;
  901. var inst = getInfos(t);
  902. var s = new haxe.Serializer();
  903. s.useEnumIndex = true;
  904. s.useCache = true;
  905. s.serialize(inst.inf);
  906. c.meta.add("rtti", [ { expr : EConst(CString(s.toString())), pos : c.pos } ], c.pos);
  907. default:
  908. }
  909. });
  910. return null;
  911. }
  912. static function getManagerInfos( t : haxe.macro.Type, pos ) {
  913. var param = null;
  914. switch( t ) {
  915. case TInst(c, p):
  916. while( true ) {
  917. if( c.toString() == "sys.db.Manager" ) {
  918. param = p[0];
  919. break;
  920. }
  921. var csup = c.get().superClass;
  922. if( csup == null ) break;
  923. c = csup.t;
  924. p = csup.params;
  925. }
  926. case TType(t, p):
  927. if( p.length == 1 && t.toString() == "sys.db.Manager" )
  928. param = p[0];
  929. default:
  930. }
  931. var inst = if( param == null ) null else getInfos(param);
  932. if( inst == null )
  933. Context.error("This method must be called from a specific Manager", Context.currentPos());
  934. inst.initManager(pos);
  935. return inst;
  936. }
  937. static function buildSQL( em : Expr, econd : Expr, prefix : String, ?eopt : Expr ) {
  938. var pos = Context.currentPos();
  939. var inst = getManagerInfos(Context.typeof(em),pos);
  940. var sql = { expr : EConst(CString(prefix + " " + inst.quoteField(inst.inf.name))), pos : econd.pos };
  941. var r = inst.buildCond(econd);
  942. if( r.t != DBool ) Context.error("Expression should be a condition", econd.pos);
  943. if( eopt != null && !Type.enumEq(eopt.expr, EConst(CIdent("null"))) ) {
  944. var opt = inst.buildOptions(eopt);
  945. if( opt.orderBy != null )
  946. r.sql = inst.sqlAddString(r.sql, " ORDER BY " + opt.orderBy);
  947. if( opt.limit != null ) {
  948. r.sql = inst.sqlAddString(r.sql, " LIMIT ");
  949. r.sql = inst.sqlAdd(r.sql, opt.limit.pos, pos);
  950. if( opt.limit.len != null ) {
  951. r.sql = inst.sqlAddString(r.sql, ",");
  952. r.sql = inst.sqlAdd(r.sql, opt.limit.len, pos);
  953. }
  954. }
  955. if( opt.forceIndex != null )
  956. sql = inst.sqlAddString(sql, " FORCE INDEX (" + inst.inf.name+"_"+opt.forceIndex+")");
  957. }
  958. sql = inst.sqlAddString(sql, " WHERE ");
  959. var sql = inst.sqlAdd(sql, r.sql, sql.pos);
  960. #if !display
  961. sql = inst.concatStrings(sql);
  962. #end
  963. return sql;
  964. }
  965. public static function macroGet( em : Expr, econd : Expr, elock : Expr ) {
  966. var pos = Context.currentPos();
  967. var inst = getManagerInfos(Context.typeof(em),pos);
  968. econd = inst.checkKeys(econd);
  969. switch( econd.expr ) {
  970. case EObjectDecl(_):
  971. return { expr : ECall({ expr : EField(em,"unsafeGetWithKeys"), pos : pos },[econd,elock]), pos : pos };
  972. default:
  973. return { expr : ECall({ expr : EField(em,"unsafeGet"), pos : pos },[econd,elock]), pos : pos };
  974. }
  975. }
  976. public static function macroSearch( em : Expr, econd : Expr, eopt : Expr, elock : Expr, ?single ) {
  977. // allow both search(e,opts) and search(e,lock)
  978. if( eopt != null && (elock == null || Type.enumEq(elock.expr, EConst(CIdent("null")))) ) {
  979. switch( eopt.expr ) {
  980. case EObjectDecl(_):
  981. default:
  982. var tmp = eopt;
  983. eopt = elock;
  984. elock = tmp;
  985. }
  986. }
  987. var sql = buildSQL(em, econd, "SELECT * FROM", eopt);
  988. var pos = Context.currentPos();
  989. var e = { expr : ECall( { expr : EField(em, "unsafeObjects"), pos : pos }, [sql,elock]), pos : pos };
  990. if( single )
  991. e = { expr : ECall( { expr : EField(e, "first"), pos : pos }, []), pos : pos };
  992. return e;
  993. }
  994. public static function macroCount( em : Expr, econd : Expr ) {
  995. var sql = buildSQL(em, econd, "SELECT COUNT(*) FROM");
  996. var pos = Context.currentPos();
  997. return { expr : ECall({ expr : EField(em,"unsafeCount"), pos : pos },[sql]), pos : pos };
  998. }
  999. public static function macroDelete( em : Expr, econd : Expr ) {
  1000. var sql = buildSQL(em, econd, "DELETE FROM");
  1001. var pos = Context.currentPos();
  1002. return { expr : ECall({ expr : EField(em,"unsafeDelete"), pos : pos },[sql]), pos : pos };
  1003. }
  1004. static var isNeko = Context.defined("neko");
  1005. public static function macroBuild() {
  1006. var fields = Context.getBuildFields();
  1007. var hasManager = false;
  1008. for( f in fields ) {
  1009. if( f.name == "manager") hasManager = true;
  1010. for( m in f.meta )
  1011. if( m.name == ":relation" ) {
  1012. switch( f.kind ) {
  1013. case FVar(t, _):
  1014. f.kind = FProp("dynamic", "dynamic", t);
  1015. if( isNeko )
  1016. continue;
  1017. var relKey = null;
  1018. var relParams = [];
  1019. var lock = false;
  1020. for( p in m.params )
  1021. switch( p.expr ) {
  1022. case EConst(c):
  1023. switch( c ) {
  1024. case CIdent(i), CType(i):
  1025. relParams.push(i);
  1026. default:
  1027. }
  1028. default:
  1029. }
  1030. relKey = relParams.shift();
  1031. for( p in relParams )
  1032. if( p == "lock" )
  1033. lock = true;
  1034. // we will get an error later
  1035. if( relKey == null )
  1036. continue;
  1037. // generate get/set methods stubs
  1038. var pos = f.pos;
  1039. var ttype = t, tname;
  1040. while( true )
  1041. switch(ttype) {
  1042. case TPath(t):
  1043. if( t.params.length == 1 && (t.name == "Null" || t.name == "SNull") ) {
  1044. ttype = switch( t.params[0] ) {
  1045. case TPType(t): t;
  1046. default: throw "assert";
  1047. };
  1048. continue;
  1049. }
  1050. var p = t.pack.copy();
  1051. p.push(t.name);
  1052. if( t.sub != null ) p.push(t.sub);
  1053. tname = p.join(".");
  1054. break;
  1055. default:
  1056. Context.error("Relation type should be a type path", f.pos);
  1057. }
  1058. function e(expr) return { expr : expr, pos : pos };
  1059. var get = {
  1060. args : [],
  1061. params : [],
  1062. ret : t,
  1063. expr : Context.parse("return untyped "+tname+".manager.__get(this,'"+f.name+"','"+relKey+"',"+lock+")",pos),
  1064. };
  1065. var set = {
  1066. args : [{ name : "_v", opt : false, type : t, value : null }],
  1067. params : [],
  1068. ret : t,
  1069. expr : Context.parse("return untyped "+tname+".manager.__set(this,'"+f.name+"','"+relKey+"',_v)",pos),
  1070. };
  1071. var meta = [{ name : ":hide", params : [], pos : pos }];
  1072. fields.push({ name : "get_"+f.name, pos : pos, meta : meta, access : [APrivate], doc : null, kind : FFun(get) });
  1073. fields.push({ name : "set_"+f.name, pos : pos, meta : meta, access : [APrivate], doc : null, kind : FFun(set) });
  1074. default:
  1075. Context.error("Invalid relation field type", f.pos);
  1076. }
  1077. break;
  1078. }
  1079. }
  1080. if( !hasManager ) {
  1081. var inst = Context.getLocalClass().get();
  1082. if( inst.meta.has(":skip") )
  1083. return fields;
  1084. var p = inst.pos;
  1085. var tinst = TPath( { pack : inst.pack, name : inst.name, sub : null, params : [] } );
  1086. var path = inst.pack.copy().concat([inst.name]).join(".");
  1087. var enew = { expr : ENew( { pack : ["sys", "db"], name : "Manager", sub : null, params : [TPType(tinst)] }, [Context.parse(path, p)]), pos : p }
  1088. fields.push({ name : "manager", meta : [], kind : FVar(null,enew), doc : null, access : [AStatic,APublic], pos : p });
  1089. }
  1090. return fields;
  1091. }
  1092. #end
  1093. }