Mercurial > urweb

annotate src/sqlcache.sml @ 2300:57f6473b1469

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
More work on heuristics.
author Ziv Scully <ziv@mit.edu>
date Thu, 19 Nov 2015 18:13:01 -0500
parents 47d5c94aeeb8
children 8d772fbf59c1
rev   line source
ziv@2291 1 structure Sqlcache :> SQLCACHE = struct
ziv@2209 2
ziv@2286 3
ziv@2286 4 (*********************)
ziv@2286 5 (* General Utilities *)
ziv@2286 6 (*********************)
ziv@2209 7
ziv@2276 8 structure IK = struct type ord_key = int val compare = Int.compare end
ziv@2209 9 structure IS = IntBinarySet
ziv@2209 10 structure IM = IntBinaryMap
ziv@2213 11 structure SK = struct type ord_key = string val compare = String.compare end
ziv@2213 12 structure SS = BinarySetFn(SK)
ziv@2213 13 structure SM = BinaryMapFn(SK)
ziv@2286 14 structure IIMM = MultimapFn(structure KeyMap = IM structure ValSet = IS)
ziv@2213 15 structure SIMM = MultimapFn(structure KeyMap = SM structure ValSet = IS)
ziv@2209 16
ziv@2274 17 fun id x = x
ziv@2274 18
ziv@2250 19 fun iterate f n x = if n < 0
ziv@2250 20 then raise Fail "Can't iterate function negative number of times."
ziv@2250 21 else if n = 0
ziv@2250 22 then x
ziv@2250 23 else iterate f (n-1) (f x)
ziv@2250 24
ziv@2286 25 (* From the MLton wiki. *)
ziv@2286 26 infix 3 <\ fun x <\ f = fn y => f (x, y) (* Left section *)
ziv@2286 27 infix 3 \> fun f \> y = f y (* Left application *)
ziv@2286 28
ziv@2286 29 fun mapFst f (x, y) = (f x, y)
ziv@2286 30
ziv@2286 31 (* Option monad. *)
ziv@2286 32 fun obind (x, f) = Option.mapPartial f x
ziv@2294 33 fun oguard (b, x) = if b then x () else NONE
ziv@2286 34 fun omap f = fn SOME x => SOME (f x) | _ => NONE
ziv@2286 35 fun omap2 f = fn (SOME x, SOME y) => SOME (f (x,y)) | _ => NONE
ziv@2286 36 fun osequence ys = List.foldr (omap2 op::) (SOME []) ys
ziv@2286 37
ziv@2294 38 fun concatMap f xs = List.concat (map f xs)
ziv@2294 39
ziv@2294 40 val rec cartesianProduct : 'a list list -> 'a list list =
ziv@2294 41 fn [] => [[]]
ziv@2294 42 | (xs :: xss) => concatMap (fn ys => concatMap (fn x => [x :: ys]) xs)
ziv@2294 43 (cartesianProduct xss)
ziv@2294 44
ziv@2286 45 fun indexOf test =
ziv@2286 46 let
ziv@2286 47 fun f n =
ziv@2286 48 fn [] => NONE
ziv@2286 49 | (x::xs) => if test x then SOME n else f (n+1) xs
ziv@2286 50 in
ziv@2286 51 f 0
ziv@2286 52 end
ziv@2286 53
ziv@2286 54
ziv@2286 55 (************)
ziv@2286 56 (* Settings *)
ziv@2286 57 (************)
ziv@2286 58
ziv@2286 59 open Mono
ziv@2286 60
ziv@2268 61 (* Filled in by [addFlushing]. *)
ziv@2268 62 val ffiInfoRef : {index : int, params : int} list ref = ref []
ziv@2209 63
ziv@2268 64 fun resetFfiInfo () = ffiInfoRef := []
ziv@2227 65
ziv@2268 66 fun getFfiInfo () = !ffiInfoRef
ziv@2213 67
ziv@2215 68 (* Some FFIs have writing as their only effect, which the caching records. *)
ziv@2215 69 val ffiEffectful =
ziv@2223 70 (* ASK: how can this be less hard-coded? *)
ziv@2215 71 let
ziv@2258 72 val okayWrites = SS.fromList ["htmlifyInt_w",
ziv@2258 73 "htmlifyFloat_w",
ziv@2258 74 "htmlifyString_w",
ziv@2258 75 "htmlifyBool_w",
ziv@2258 76 "htmlifyTime_w",
ziv@2258 77 "attrifyInt_w",
ziv@2258 78 "attrifyFloat_w",
ziv@2258 79 "attrifyString_w",
ziv@2258 80 "attrifyChar_w",
ziv@2258 81 "urlifyInt_w",
ziv@2258 82 "urlifyFloat_w",
ziv@2258 83 "urlifyString_w",
ziv@2258 84 "urlifyBool_w",
ziv@2258 85 "urlifyChannel_w"]
ziv@2215 86 in
ziv@2265 87 (* ASK: is it okay to hardcode Sqlcache functions as effectful? *)
ziv@2215 88 fn (m, f) => Settings.isEffectful (m, f)
ziv@2258 89 andalso not (m = "Basis" andalso SS.member (okayWrites, f))
ziv@2215 90 end
ziv@2215 91
ziv@2278 92 val cacheRef = ref LruCache.cache
ziv@2278 93 fun setCache c = cacheRef := c
ziv@2278 94 fun getCache () = !cacheRef
ziv@2278 95
ziv@2300 96 datatype heuristic = SmartEq (* | SmartSub *) | Always | Never | NoPureAll | NoPureOne | NoCombo
ziv@2299 97
ziv@2299 98 val heuristicRef = ref Always
ziv@2299 99 fun setHeuristic h = heuristicRef := (case h of
ziv@2300 100 "smarteq" => SmartEq
ziv@2300 101 (* | "smartsub" => SmartSub *)
ziv@2300 102 | "always" => Always
ziv@2299 103 | "never" => Never
ziv@2299 104 | "nopureall" => NoPureAll
ziv@2299 105 | "nopureone" => NoPureOne
ziv@2299 106 | "nocombo" => NoCombo
ziv@2299 107 | _ => raise Fail "Sqlcache: setHeuristic")
ziv@2299 108 fun getHeuristic () = !heuristicRef
ziv@2233 109
ziv@2286 110
ziv@2286 111 (************************)
ziv@2286 112 (* Really Useful Things *)
ziv@2286 113 (************************)
ziv@2286 114
ziv@2248 115 (* Used to have type context for local variables in MonoUtil functions. *)
ziv@2248 116 val doBind =
ziv@2262 117 fn (env, MonoUtil.Exp.RelE (x, t)) => MonoEnv.pushERel env x t NONE
ziv@2262 118 | (env, MonoUtil.Exp.NamedE (x, n, t, eo, s)) => MonoEnv.pushENamed env x n t eo s
ziv@2262 119 | (env, MonoUtil.Exp.Datatype (x, n, cs)) => MonoEnv.pushDatatype env x n cs
ziv@2215 120
ziv@2271 121 val dummyLoc = ErrorMsg.dummySpan
ziv@2271 122
ziv@2278 123 (* DEBUG *)
ziv@2294 124 fun printExp msg exp =
ziv@2294 125 (Print.preface ("SQLCACHE: " ^ msg ^ ":", MonoPrint.p_exp MonoEnv.empty exp); exp)
ziv@2294 126 fun printExp' msg exp' = (printExp msg (exp', dummyLoc); exp')
ziv@2294 127 fun printTyp msg typ =
ziv@2294 128 (Print.preface ("SQLCACHE: " ^ msg ^ ":", MonoPrint.p_typ MonoEnv.empty typ); typ)
ziv@2294 129 fun printTyp' msg typ' = (printTyp msg (typ', dummyLoc); typ')
ziv@2278 130 fun obindDebug printer (x, f) =
ziv@2278 131 case x of
ziv@2278 132 NONE => NONE
ziv@2278 133 | SOME x' => case f x' of
ziv@2278 134 NONE => (printer (); NONE)
ziv@2278 135 | y => y
ziv@2271 136
ziv@2268 137
ziv@2248 138 (*******************)
ziv@2248 139 (* Effect Analysis *)
ziv@2248 140 (*******************)
ziv@2215 141
ziv@2286 142 (* TODO: test this. *)
ziv@2286 143 fun transitiveAnalysis doVal state (decls, _) =
ziv@2286 144 let
ziv@2286 145 val doDecl =
ziv@2286 146 fn ((DVal v, _), state) => doVal (v, state)
ziv@2286 147 (* Pass over the list of values a number of times equal to its size,
ziv@2286 148 making sure whatever property we're testing propagates everywhere
ziv@2286 149 it should. This is analagous to the Bellman-Ford algorithm. *)
ziv@2286 150 | ((DValRec vs, _), state) =>
ziv@2286 151 iterate (fn state => List.foldl doVal state vs) (length vs) state
ziv@2286 152 | (_, state) => state
ziv@2286 153 in
ziv@2286 154 List.foldl doDecl state decls
ziv@2286 155 end
ziv@2286 156
ziv@2216 157 (* Makes an exception for [EWrite] (which is recorded when caching). *)
ziv@2248 158 fun effectful (effs : IS.set) =
ziv@2215 159 let
ziv@2248 160 val isFunction =
ziv@2248 161 fn (TFun _, _) => true
ziv@2248 162 | _ => false
ziv@2250 163 fun doExp (env, e) =
ziv@2248 164 case e of
ziv@2248 165 EPrim _ => false
ziv@2248 166 (* For now: variables of function type might be effectful, but
ziv@2248 167 others are fully evaluated and are therefore not effectful. *)
ziv@2250 168 | ERel n => isFunction (#2 (MonoEnv.lookupERel env n))
ziv@2248 169 | ENamed n => IS.member (effs, n)
ziv@2248 170 | EFfi (m, f) => ffiEffectful (m, f)
ziv@2248 171 | EFfiApp (m, f, _) => ffiEffectful (m, f)
ziv@2248 172 (* These aren't effectful unless a subexpression is. *)
ziv@2248 173 | ECon _ => false
ziv@2248 174 | ENone _ => false
ziv@2248 175 | ESome _ => false
ziv@2248 176 | EApp _ => false
ziv@2248 177 | EAbs _ => false
ziv@2248 178 | EUnop _ => false
ziv@2248 179 | EBinop _ => false
ziv@2248 180 | ERecord _ => false
ziv@2248 181 | EField _ => false
ziv@2248 182 | ECase _ => false
ziv@2248 183 | EStrcat _ => false
ziv@2248 184 (* EWrite is a special exception because we record writes when caching. *)
ziv@2248 185 | EWrite _ => false
ziv@2248 186 | ESeq _ => false
ziv@2248 187 | ELet _ => false
ziv@2250 188 | EUnurlify _ => false
ziv@2248 189 (* ASK: what should we do about closures? *)
ziv@2248 190 (* Everything else is some sort of effect. We could flip this and
ziv@2248 191 explicitly list bits of Mono that are effectful, but this is
ziv@2248 192 conservatively robust to future changes (however unlikely). *)
ziv@2248 193 | _ => true
ziv@2215 194 in
ziv@2248 195 MonoUtil.Exp.existsB {typ = fn _ => false, exp = doExp, bind = doBind}
ziv@2215 196 end
ziv@2215 197
ziv@2215 198 (* TODO: test this. *)
ziv@2286 199 fun effectfulDecls file =
ziv@2286 200 transitiveAnalysis (fn ((_, name, _, e, _), effs) =>
ziv@2286 201 if effectful effs MonoEnv.empty e
ziv@2286 202 then IS.add (effs, name)
ziv@2286 203 else effs)
ziv@2286 204 IS.empty
ziv@2286 205 file
ziv@2215 206
ziv@2215 207
ziv@2248 208 (*********************************)
ziv@2248 209 (* Boolean Formula Normalization *)
ziv@2248 210 (*********************************)
ziv@2216 211
ziv@2234 212 datatype junctionType = Conj | Disj
ziv@2216 213
ziv@2216 214 datatype 'atom formula =
ziv@2216 215 Atom of 'atom
ziv@2216 216 | Negate of 'atom formula
ziv@2234 217 | Combo of junctionType * 'atom formula list
ziv@2216 218
ziv@2243 219 (* Guaranteed to have all negation pushed to the atoms. *)
ziv@2243 220 datatype 'atom formula' =
ziv@2243 221 Atom' of 'atom
ziv@2243 222 | Combo' of junctionType * 'atom formula' list
ziv@2243 223
ziv@2234 224 val flipJt = fn Conj => Disj | Disj => Conj
ziv@2216 225
ziv@2218 226 (* Pushes all negation to the atoms.*)
ziv@2244 227 fun pushNegate (normalizeAtom : bool * 'atom -> 'atom) (negating : bool) =
ziv@2244 228 fn Atom x => Atom' (normalizeAtom (negating, x))
ziv@2244 229 | Negate f => pushNegate normalizeAtom (not negating) f
ziv@2244 230 | Combo (j, fs) => Combo' (if negating then flipJt j else j,
ziv@2244 231 map (pushNegate normalizeAtom negating) fs)
ziv@2218 232
ziv@2218 233 val rec flatten =
ziv@2243 234 fn Combo' (_, [f]) => flatten f
ziv@2243 235 | Combo' (j, fs) =>
ziv@2243 236 Combo' (j, List.foldr (fn (f, acc) =>
ziv@2243 237 case f of
ziv@2243 238 Combo' (j', fs') =>
ziv@2243 239 if j = j' orelse length fs' = 1
ziv@2243 240 then fs' @ acc
ziv@2243 241 else f :: acc
ziv@2243 242 | _ => f :: acc)
ziv@2243 243 []
ziv@2243 244 (map flatten fs))
ziv@2218 245 | f => f
ziv@2218 246
ziv@2243 247 (* [simplify] operates on the desired normal form. E.g., if [junc] is [Disj],
ziv@2243 248 consider the list of lists to be a disjunction of conjunctions. *)
ziv@2237 249 fun normalize' (simplify : 'a list list -> 'a list list)
ziv@2235 250 (junc : junctionType) =
ziv@2216 251 let
ziv@2235 252 fun norm junc =
ziv@2237 253 simplify
ziv@2243 254 o (fn Atom' x => [[x]]
ziv@2243 255 | Combo' (j, fs) =>
ziv@2235 256 let
ziv@2236 257 val fss = map (norm junc) fs
ziv@2235 258 in
ziv@2236 259 if j = junc
ziv@2236 260 then List.concat fss
ziv@2236 261 else map List.concat (cartesianProduct fss)
ziv@2235 262 end)
ziv@2216 263 in
ziv@2235 264 norm junc
ziv@2216 265 end
ziv@2216 266
ziv@2244 267 fun normalize simplify normalizeAtom junc =
ziv@2243 268 normalize' simplify junc
ziv@2235 269 o flatten
ziv@2244 270 o pushNegate normalizeAtom false
ziv@2216 271
ziv@2221 272 fun mapFormula mf =
ziv@2221 273 fn Atom x => Atom (mf x)
ziv@2221 274 | Negate f => Negate (mapFormula mf f)
ziv@2235 275 | Combo (j, fs) => Combo (j, map (mapFormula mf) fs)
ziv@2216 276
ziv@2274 277 fun mapFormulaExps mf = mapFormula (fn (cmp, e1, e2) => (cmp, mf e1, mf e2))
ziv@2274 278
ziv@2230 279
ziv@2248 280 (****************)
ziv@2248 281 (* SQL Analysis *)
ziv@2248 282 (****************)
ziv@2213 283
ziv@2240 284 structure CmpKey = struct
ziv@2235 285
ziv@2235 286 type ord_key = Sql.cmp
ziv@2235 287
ziv@2235 288 val compare =
ziv@2235 289 fn (Sql.Eq, Sql.Eq) => EQUAL
ziv@2235 290 | (Sql.Eq, _) => LESS
ziv@2235 291 | (_, Sql.Eq) => GREATER
ziv@2235 292 | (Sql.Ne, Sql.Ne) => EQUAL
ziv@2235 293 | (Sql.Ne, _) => LESS
ziv@2235 294 | (_, Sql.Ne) => GREATER
ziv@2235 295 | (Sql.Lt, Sql.Lt) => EQUAL
ziv@2235 296 | (Sql.Lt, _) => LESS
ziv@2235 297 | (_, Sql.Lt) => GREATER
ziv@2235 298 | (Sql.Le, Sql.Le) => EQUAL
ziv@2235 299 | (Sql.Le, _) => LESS
ziv@2235 300 | (_, Sql.Le) => GREATER
ziv@2235 301 | (Sql.Gt, Sql.Gt) => EQUAL
ziv@2235 302 | (Sql.Gt, _) => LESS
ziv@2235 303 | (_, Sql.Gt) => GREATER
ziv@2235 304 | (Sql.Ge, Sql.Ge) => EQUAL
ziv@2235 305
ziv@2235 306 end
ziv@2235 307
ziv@2216 308 val rec chooseTwos : 'a list -> ('a * 'a) list =
ziv@2216 309 fn [] => []
ziv@2216 310 | x :: ys => map (fn y => (x, y)) ys @ chooseTwos ys
ziv@2213 311
ziv@2237 312 fun removeRedundant madeRedundantBy zs =
ziv@2237 313 let
ziv@2237 314 fun removeRedundant' (xs, ys) =
ziv@2237 315 case xs of
ziv@2237 316 [] => ys
ziv@2237 317 | x :: xs' =>
ziv@2237 318 removeRedundant' (xs',
ziv@2237 319 if List.exists (fn y => madeRedundantBy (x, y)) (xs' @ ys)
ziv@2237 320 then ys
ziv@2237 321 else x :: ys)
ziv@2237 322 in
ziv@2237 323 removeRedundant' (zs, [])
ziv@2237 324 end
ziv@2237 325
ziv@2216 326 datatype atomExp =
ziv@2289 327 True
ziv@2289 328 | False
ziv@2289 329 | QueryArg of int
ziv@2216 330 | DmlRel of int
ziv@2216 331 | Prim of Prim.t
ziv@2216 332 | Field of string * string
ziv@2216 333
ziv@2216 334 structure AtomExpKey : ORD_KEY = struct
ziv@2216 335
ziv@2234 336 type ord_key = atomExp
ziv@2216 337
ziv@2234 338 val compare =
ziv@2289 339 fn (True, True) => EQUAL
ziv@2289 340 | (True, _) => LESS
ziv@2289 341 | (_, True) => GREATER
ziv@2289 342 | (False, False) => EQUAL
ziv@2289 343 | (False, _) => LESS
ziv@2289 344 | (_, False) => GREATER
ziv@2289 345 | (QueryArg n1, QueryArg n2) => Int.compare (n1, n2)
ziv@2234 346 | (QueryArg _, _) => LESS
ziv@2234 347 | (_, QueryArg _) => GREATER
ziv@2234 348 | (DmlRel n1, DmlRel n2) => Int.compare (n1, n2)
ziv@2234 349 | (DmlRel _, _) => LESS
ziv@2234 350 | (_, DmlRel _) => GREATER
ziv@2234 351 | (Prim p1, Prim p2) => Prim.compare (p1, p2)
ziv@2234 352 | (Prim _, _) => LESS
ziv@2234 353 | (_, Prim _) => GREATER
ziv@2234 354 | (Field (t1, f1), Field (t2, f2)) =>
ziv@2234 355 case String.compare (t1, t2) of
ziv@2234 356 EQUAL => String.compare (f1, f2)
ziv@2234 357 | ord => ord
ziv@2216 358
ziv@2216 359 end
ziv@2216 360
ziv@2244 361 structure AtomOptionKey = OptionKeyFn(AtomExpKey)
ziv@2244 362
ziv@2271 363 val rec tablesOfQuery =
ziv@2294 364 fn Sql.Query1 {From = fitems, ...} => List.foldl SS.union SS.empty (map tableOfFitem fitems)
ziv@2271 365 | Sql.Union (q1, q2) => SS.union (tablesOfQuery q1, tablesOfQuery q2)
ziv@2294 366 and tableOfFitem =
ziv@2294 367 fn Sql.Table (t, _) => SS.singleton t
ziv@2294 368 | Sql.Nested (q, _) => tablesOfQuery q
ziv@2294 369 | Sql.Join (_, f1, f2, _) => SS.union (tableOfFitem f1, tableOfFitem f2)
ziv@2271 370
ziv@2271 371 val tableOfDml =
ziv@2271 372 fn Sql.Insert (tab, _) => tab
ziv@2271 373 | Sql.Delete (tab, _) => tab
ziv@2271 374 | Sql.Update (tab, _, _) => tab
ziv@2271 375
ziv@2271 376 val freeVars =
ziv@2271 377 MonoUtil.Exp.foldB
ziv@2271 378 {typ = #2,
ziv@2271 379 exp = fn (bound, ERel n, vars) => if n < bound
ziv@2271 380 then vars
ziv@2271 381 else IS.add (vars, n - bound)
ziv@2271 382 | (_, _, vars) => vars,
ziv@2273 383 bind = fn (bound, MonoUtil.Exp.RelE _) => bound + 1
ziv@2273 384 | (bound, _) => bound}
ziv@2271 385 0
ziv@2271 386 IS.empty
ziv@2271 387
ziv@2276 388 (* A path is a number of field projections of a variable. *)
ziv@2278 389 type path = int * string list
ziv@2276 390 structure PK = PairKeyFn(structure I = IK structure J = ListKeyFn(SK))
ziv@2276 391 structure PS = BinarySetFn(PK)
ziv@2276 392
ziv@2276 393 val pathOfExp =
ziv@2276 394 let
ziv@2276 395 fun readFields acc exp =
ziv@2276 396 acc
ziv@2276 397 <\obind\>
ziv@2276 398 (fn fs =>
ziv@2276 399 case #1 exp of
ziv@2276 400 ERel n => SOME (n, fs)
ziv@2276 401 | EField (exp, f) => readFields (SOME (f::fs)) exp
ziv@2276 402 | _ => NONE)
ziv@2276 403 in
ziv@2276 404 readFields (SOME [])
ziv@2276 405 end
ziv@2276 406
ziv@2276 407 fun expOfPath (n, fs) =
ziv@2276 408 List.foldl (fn (f, exp) => (EField (exp, f), dummyLoc)) (ERel n, dummyLoc) fs
ziv@2276 409
ziv@2276 410 fun freePaths'' bound exp paths =
ziv@2276 411 case pathOfExp (exp, dummyLoc) of
ziv@2276 412 NONE => paths
ziv@2276 413 | SOME (n, fs) => if n < bound then paths else PS.add (paths, (n - bound, fs))
ziv@2276 414
ziv@2276 415 (* ASK: nicer way? :( *)
ziv@2276 416 fun freePaths' bound exp =
ziv@2276 417 case #1 exp of
ziv@2276 418 EPrim _ => id
ziv@2276 419 | e as ERel _ => freePaths'' bound e
ziv@2276 420 | ENamed _ => id
ziv@2276 421 | ECon (_, _, data) => (case data of NONE => id | SOME e => freePaths' bound e)
ziv@2276 422 | ENone _ => id
ziv@2276 423 | ESome (_, e) => freePaths' bound e
ziv@2276 424 | EFfi _ => id
ziv@2276 425 | EFfiApp (_, _, args) =>
ziv@2276 426 List.foldl (fn ((e, _), acc) => freePaths' bound e o acc) id args
ziv@2276 427 | EApp (e1, e2) => freePaths' bound e1 o freePaths' bound e2
ziv@2276 428 | EAbs (_, _, _, e) => freePaths' (bound + 1) e
ziv@2276 429 | EUnop (_, e) => freePaths' bound e
ziv@2276 430 | EBinop (_, _, e1, e2) => freePaths' bound e1 o freePaths' bound e2
ziv@2276 431 | ERecord fields => List.foldl (fn ((_, e, _), acc) => freePaths' bound e o acc) id fields
ziv@2276 432 | e as EField _ => freePaths'' bound e
ziv@2276 433 | ECase (e, cases, _) =>
ziv@2278 434 List.foldl (fn ((p, e), acc) => freePaths' (MonoEnv.patBindsN p + bound) e o acc)
ziv@2276 435 (freePaths' bound e)
ziv@2276 436 cases
ziv@2276 437 | EStrcat (e1, e2) => freePaths' bound e1 o freePaths' bound e2
ziv@2276 438 | EError (e, _) => freePaths' bound e
ziv@2276 439 | EReturnBlob {blob, mimeType = e, ...} =>
ziv@2276 440 freePaths' bound e o (case blob of NONE => id | SOME e => freePaths' bound e)
ziv@2276 441 | ERedirect (e, _) => freePaths' bound e
ziv@2276 442 | EWrite e => freePaths' bound e
ziv@2276 443 | ESeq (e1, e2) => freePaths' bound e1 o freePaths' bound e2
ziv@2278 444 | ELet (_, _, e1, e2) => freePaths' bound e1 o freePaths' (bound + 1) e2
ziv@2276 445 | EClosure (_, es) => List.foldl (fn (e, acc) => freePaths' bound e o acc) id es
ziv@2276 446 | EQuery {query = e1, body = e2, initial = e3, ...} =>
ziv@2276 447 freePaths' bound e1 o freePaths' (bound + 2) e2 o freePaths' bound e3
ziv@2276 448 | EDml (e, _) => freePaths' bound e
ziv@2276 449 | ENextval e => freePaths' bound e
ziv@2276 450 | ESetval (e1, e2) => freePaths' bound e1 o freePaths' bound e2
ziv@2276 451 | EUnurlify (e, _, _) => freePaths' bound e
ziv@2276 452 | EJavaScript (_, e) => freePaths' bound e
ziv@2276 453 | ESignalReturn e => freePaths' bound e
ziv@2276 454 | ESignalBind (e1, e2) => freePaths' bound e1 o freePaths' bound e2
ziv@2276 455 | ESignalSource e => freePaths' bound e
ziv@2276 456 | EServerCall (e, _, _, _) => freePaths' bound e
ziv@2276 457 | ERecv (e, _) => freePaths' bound e
ziv@2276 458 | ESleep e => freePaths' bound e
ziv@2276 459 | ESpawn e => freePaths' bound e
ziv@2276 460
ziv@2276 461 fun freePaths exp = freePaths' 0 exp PS.empty
ziv@2276 462
ziv@2271 463 datatype unbind = Known of exp | Unknowns of int
ziv@2271 464
ziv@2273 465 datatype cacheArg = AsIs of exp | Urlify of exp
ziv@2273 466
ziv@2278 467 structure InvalInfo :> sig
ziv@2271 468 type t
ziv@2271 469 type state = {tableToIndices : SIMM.multimap,
ziv@2271 470 indexToInvalInfo : (t * int) IntBinaryMap.map,
ziv@2271 471 ffiInfo : {index : int, params : int} list,
ziv@2271 472 index : int}
ziv@2271 473 val empty : t
ziv@2271 474 val singleton : Sql.query -> t
ziv@2271 475 val query : t -> Sql.query
ziv@2299 476 val orderArgs : t * Mono.exp -> cacheArg list option
ziv@2271 477 val unbind : t * unbind -> t option
ziv@2271 478 val union : t * t -> t
ziv@2271 479 val updateState : t * int * state -> state
ziv@2278 480 end = struct
ziv@2271 481
ziv@2276 482 (* Variable, field projections, possible wrapped sqlification FFI call. *)
ziv@2278 483 type sqlArg = path * (string * string * typ) option
ziv@2273 484
ziv@2273 485 type subst = sqlArg IM.map
ziv@2273 486
ziv@2273 487 (* TODO: store free variables as well? *)
ziv@2273 488 type t = (Sql.query * subst) list
ziv@2271 489
ziv@2271 490 type state = {tableToIndices : SIMM.multimap,
ziv@2271 491 indexToInvalInfo : (t * int) IntBinaryMap.map,
ziv@2271 492 ffiInfo : {index : int, params : int} list,
ziv@2271 493 index : int}
ziv@2271 494
ziv@2278 495 structure AK = PairKeyFn(
ziv@2278 496 structure I = PK
ziv@2278 497 structure J = OptionKeyFn(TripleKeyFn(
ziv@2276 498 structure I = SK
ziv@2276 499 structure J = SK
ziv@2276 500 structure K = struct type ord_key = Mono.typ val compare = MonoUtil.Typ.compare end)))
ziv@2276 501 structure AM = BinaryMapFn(AK)
ziv@2271 502
ziv@2273 503 (* Traversal Utilities *)
ziv@2273 504 (* TODO: get rid of unused ones. *)
ziv@2271 505
ziv@2271 506 (* Need lift', etc. because we don't have rank-2 polymorphism. This should
ziv@2273 507 probably use a functor (an ML one, not Haskell) but works for now. *)
ziv@2294 508 fun traverseSqexp (pure, _, _, _, lift, lift', _, _, lift2, _, _, _, _, _) f =
ziv@2271 509 let
ziv@2271 510 val rec tr =
ziv@2271 511 fn Sql.SqNot se => lift Sql.SqNot (tr se)
ziv@2271 512 | Sql.Binop (r, se1, se2) =>
ziv@2271 513 lift2 (fn (trse1, trse2) => Sql.Binop (r, trse1, trse2)) (tr se1, tr se2)
ziv@2271 514 | Sql.SqKnown se => lift Sql.SqKnown (tr se)
ziv@2294 515 | Sql.Inj (e', loc) => lift' (fn fe' => Sql.Inj (fe', loc)) (f e')
ziv@2271 516 | Sql.SqFunc (s, se) => lift (fn trse => Sql.SqFunc (s, trse)) (tr se)
ziv@2271 517 | se => pure se
ziv@2271 518 in
ziv@2271 519 tr
ziv@2271 520 end
ziv@2271 521
ziv@2294 522 fun traverseFitem (ops as (_, _, _, pure''', _, _, _, lift''', _, _, _, _, lift2'''', lift2''''')) f =
ziv@2271 523 let
ziv@2294 524 val rec tr =
ziv@2294 525 fn Sql.Table t => pure''' (Sql.Table t)
ziv@2294 526 | Sql.Join (jt, fi1, fi2, se) =>
ziv@2294 527 lift2'''' (fn ((trfi1, trfi2), trse) => Sql.Join (jt, trfi1, trfi2, trse))
ziv@2294 528 (lift2''''' id (tr fi1, tr fi2), traverseSqexp ops f se)
ziv@2294 529 | Sql.Nested (q, s) => lift''' (fn trq => Sql.Nested (trq, s))
ziv@2294 530 (traverseQuery ops f q)
ziv@2294 531 in
ziv@2294 532 tr
ziv@2294 533 end
ziv@2294 534
ziv@2294 535 and traverseQuery (ops as (_, pure', pure'', _, _, _, lift'', _, _, lift2', lift2'', lift2''', _, _)) f =
ziv@2294 536 let
ziv@2294 537 val rec seqList =
ziv@2294 538 fn [] => pure'' []
ziv@2294 539 | (x::xs) => lift2''' op:: (x, seqList xs)
ziv@2294 540 val rec tr =
ziv@2271 541 fn Sql.Query1 q =>
ziv@2294 542 (* TODO: make sure we don't need to traverse [#Select q]. *)
ziv@2294 543 lift2' (fn (trfrom, trwher) => Sql.Query1 {Select = #Select q,
ziv@2294 544 From = trfrom,
ziv@2294 545 Where = trwher})
ziv@2294 546 (seqList (map (traverseFitem ops f) (#From q)),
ziv@2294 547 case #Where q of
ziv@2294 548 NONE => pure' NONE
ziv@2294 549 | SOME se => lift'' SOME (traverseSqexp ops f se))
ziv@2294 550 | Sql.Union (q1, q2) => lift2'' Sql.Union (tr q1, tr q2)
ziv@2271 551 in
ziv@2294 552 tr
ziv@2271 553 end
ziv@2271 554
ziv@2273 555 (* Include unused tuple elements in argument for convenience of using same
ziv@2273 556 argument as [traverseQuery]. *)
ziv@2294 557 fun traverseIM (pure, _, _, _, _, _, _, _, _, lift2, _, _, _, _) f =
ziv@2273 558 IM.foldli (fn (k, v, acc) => lift2 (fn (acc, w) => IM.insert (acc, k, w)) (acc, f (k,v)))
ziv@2273 559 (pure IM.empty)
ziv@2271 560
ziv@2294 561 fun traverseSubst (ops as (_, pure', _, _, lift, _, _, _, _, lift2', _, _, _, _)) f =
ziv@2273 562 let
ziv@2278 563 fun mp ((n, fields), sqlify) =
ziv@2278 564 lift (fn ((n', fields'), sqlify') =>
ziv@2276 565 let
ziv@2278 566 fun wrap sq = ((n', fields' @ fields), sq)
ziv@2276 567 in
ziv@2276 568 case (fields', sqlify', fields, sqlify) of
ziv@2276 569 (_, NONE, _, NONE) => wrap NONE
ziv@2276 570 | (_, NONE, _, sq as SOME _) => wrap sq
ziv@2276 571 (* Last case should suffice because we don't
ziv@2276 572 project from a sqlified value (which is a
ziv@2276 573 string). *)
ziv@2276 574 | (_, sq as SOME _, [], NONE) => wrap sq
ziv@2289 575 | _ => raise Fail "Sqlcache: traverseSubst"
ziv@2276 576 end)
ziv@2276 577 (f n)
ziv@2273 578 in
ziv@2273 579 traverseIM ops (fn (_, v) => mp v)
ziv@2273 580 end
ziv@2273 581
ziv@2294 582 fun monoidOps plus zero =
ziv@2294 583 (fn _ => zero, fn _ => zero, fn _ => zero, fn _ => zero,
ziv@2294 584 fn _ => fn x => x, fn _ => fn x => x, fn _ => fn x => x, fn _ => fn x => x,
ziv@2294 585 fn _ => plus, fn _ => plus, fn _ => plus, fn _ => plus, fn _ => plus, fn _ => plus)
ziv@2273 586
ziv@2294 587 val optionOps = (SOME, SOME, SOME, SOME,
ziv@2294 588 omap, omap, omap, omap,
ziv@2294 589 omap2, omap2, omap2, omap2, omap2, omap2)
ziv@2273 590
ziv@2273 591 fun foldMapQuery plus zero = traverseQuery (monoidOps plus zero)
ziv@2273 592 val omapQuery = traverseQuery optionOps
ziv@2273 593 fun foldMapIM plus zero = traverseIM (monoidOps plus zero)
ziv@2273 594 fun omapIM f = traverseIM optionOps f
ziv@2273 595 fun foldMapSubst plus zero = traverseSubst (monoidOps plus zero)
ziv@2273 596 fun omapSubst f = traverseSubst optionOps f
ziv@2271 597
ziv@2271 598 val varsOfQuery = foldMapQuery IS.union
ziv@2271 599 IS.empty
ziv@2271 600 (fn e' => freeVars (e', dummyLoc))
ziv@2271 601
ziv@2276 602 fun varsOfSubst subst = foldMapSubst IS.union IS.empty IS.singleton subst
ziv@2273 603
ziv@2271 604 val varsOfList =
ziv@2271 605 fn [] => IS.empty
ziv@2271 606 | (q::qs) => varsOfQuery (List.foldl Sql.Union q qs)
ziv@2271 607
ziv@2273 608 (* Signature Implementation *)
ziv@2273 609
ziv@2273 610 val empty = []
ziv@2273 611
ziv@2278 612 fun singleton q = [(q, IS.foldl (fn (n, acc) => IM.insert (acc, n, ((n, []), NONE)))
ziv@2273 613 IM.empty
ziv@2273 614 (varsOfQuery q))]
ziv@2273 615
ziv@2273 616 val union = op@
ziv@2273 617
ziv@2300 618 fun addToSqlArgsMap ((q, subst), acc) =
ziv@2300 619 IM.foldl (fn (arg, acc) => AM.insert (acc, arg, ())) acc subst
ziv@2300 620
ziv@2273 621 fun sqlArgsMap (qs : t) =
ziv@2271 622 let
ziv@2273 623 val args =
ziv@2300 624 List.foldl addToSqlArgsMap AM.empty qs
ziv@2273 625 val countRef = ref (~1)
ziv@2273 626 fun count () = (countRef := !countRef + 1; !countRef)
ziv@2273 627 in
ziv@2273 628 (* Maps each arg to a different consecutive integer, starting from 0. *)
ziv@2273 629 AM.map count args
ziv@2273 630 end
ziv@2273 631
ziv@2278 632 fun expOfArg (path, sqlify) =
ziv@2276 633 let
ziv@2278 634 val exp = expOfPath path
ziv@2276 635 in
ziv@2276 636 case sqlify of
ziv@2276 637 NONE => exp
ziv@2276 638 | SOME (m, x, typ) => (EFfiApp (m, x, [(exp, typ)]), dummyLoc)
ziv@2276 639 end
ziv@2273 640
ziv@2278 641 fun orderArgs (qs : t, exp) =
ziv@2273 642 let
ziv@2278 643 val paths = freePaths exp
ziv@2273 644 fun erel n = (ERel n, dummyLoc)
ziv@2273 645 val argsMap = sqlArgsMap qs
ziv@2273 646 val args = map (expOfArg o #1) (AM.listItemsi argsMap)
ziv@2276 647 val invalPaths = List.foldl PS.union PS.empty (map freePaths args)
ziv@2299 648 (* TODO: make sure these variables are okay to remove from the argument list. *)
ziv@2299 649 val pureArgs = PS.difference (paths, invalPaths)
ziv@2299 650 val shouldCache =
ziv@2299 651 case getHeuristic () of
ziv@2300 652 SmartEq =>
ziv@2300 653 (case (qs, PS.numItems pureArgs) of
ziv@2300 654 ((q::qs), 0) =>
ziv@2300 655 let
ziv@2300 656 val m = addToSqlArgsMap (q, AM.empty)
ziv@2300 657 val ms = map (fn q => addToSqlArgsMap (q, AM.empty)) qs
ziv@2300 658 fun test (m, acc) =
ziv@2300 659 acc
ziv@2300 660 <\obind\>
ziv@2300 661 (fn m' =>
ziv@2300 662 let
ziv@2300 663 val mm = AM.unionWith #1 (m, m')
ziv@2300 664 in
ziv@2300 665 AM.numItems m = AM.numItems mm
ziv@2300 666 <\oguard\>
ziv@2300 667 (fn _ => SOME mm)
ziv@2300 668 end)
ziv@2300 669 in
ziv@2300 670 case List.foldl test (SOME m) ms of
ziv@2300 671 NONE => false
ziv@2300 672 | SOME _ => true
ziv@2300 673 end
ziv@2300 674 | _ => false)
ziv@2300 675 | Always => true
ziv@2300 676 | Never => (case qs of [_] => PS.numItems pureArgs = 0 | _ => false)
ziv@2299 677 | NoPureAll => (case qs of [] => false | _ => true)
ziv@2299 678 | NoPureOne => (case qs of [] => false | _ => PS.numItems pureArgs = 0)
ziv@2299 679 | NoCombo => PS.numItems pureArgs = 0 orelse AM.numItems argsMap = 0
ziv@2271 680 in
ziv@2271 681 (* Put arguments we might invalidate by first. *)
ziv@2299 682 if shouldCache
ziv@2299 683 then SOME (map AsIs args @ map (Urlify o expOfPath) (PS.listItems pureArgs))
ziv@2299 684 else NONE
ziv@2271 685 end
ziv@2271 686
ziv@2271 687 (* As a kludge, we rename the variables in the query to correspond to the
ziv@2271 688 argument of the cache they're part of. *)
ziv@2273 689 fun query (qs : t) =
ziv@2271 690 let
ziv@2273 691 val argsMap = sqlArgsMap qs
ziv@2273 692 fun substitute subst =
ziv@2273 693 fn ERel n => IM.find (subst, n)
ziv@2273 694 <\obind\>
ziv@2273 695 (fn arg =>
ziv@2273 696 AM.find (argsMap, arg)
ziv@2273 697 <\obind\>
ziv@2273 698 (fn n' => SOME (ERel n')))
ziv@2289 699 | _ => raise Fail "Sqlcache: query (a)"
ziv@2271 700 in
ziv@2273 701 case (map #1 qs) of
ziv@2273 702 (q :: qs) =>
ziv@2273 703 let
ziv@2273 704 val q = List.foldl Sql.Union q qs
ziv@2273 705 val ns = IS.listItems (varsOfQuery q)
ziv@2273 706 val rename =
ziv@2273 707 fn ERel n => omap ERel (indexOf (fn n' => n' = n) ns)
ziv@2289 708 | _ => raise Fail "Sqlcache: query (b)"
ziv@2273 709 in
ziv@2273 710 case omapQuery rename q of
ziv@2273 711 SOME q => q
ziv@2273 712 (* We should never get NONE because indexOf should never fail. *)
ziv@2289 713 | NONE => raise Fail "Sqlcache: query (c)"
ziv@2273 714 end
ziv@2273 715 (* We should never reach this case because [updateState] won't
ziv@2273 716 put anything in the state if there are no queries. *)
ziv@2289 717 | [] => raise Fail "Sqlcache: query (d)"
ziv@2271 718 end
ziv@2271 719
ziv@2276 720 val argOfExp =
ziv@2276 721 let
ziv@2276 722 fun doFields acc exp =
ziv@2276 723 acc
ziv@2276 724 <\obind\>
ziv@2276 725 (fn (fs, sqlify) =>
ziv@2276 726 case #1 exp of
ziv@2276 727 ERel n => SOME (n, fs, sqlify)
ziv@2276 728 | EField (exp, f) => doFields (SOME (f::fs, sqlify)) exp
ziv@2276 729 | _ => NONE)
ziv@2276 730 in
ziv@2276 731 fn (EFfiApp ("Basis", x, [(exp, typ)]), _) =>
ziv@2276 732 if String.isPrefix "sqlify" x
ziv@2278 733 then omap (fn path => (path, SOME ("Basis", x, typ))) (pathOfExp exp)
ziv@2276 734 else NONE
ziv@2278 735 | exp => omap (fn path => (path, NONE)) (pathOfExp exp)
ziv@2276 736 end
ziv@2273 737
ziv@2273 738 val unbind1 =
ziv@2273 739 fn Known e =>
ziv@2273 740 let
ziv@2273 741 val replacement = argOfExp e
ziv@2273 742 in
ziv@2273 743 omapSubst (fn 0 => replacement
ziv@2278 744 | n => SOME ((n-1, []), NONE))
ziv@2273 745 end
ziv@2278 746 | Unknowns k => omapSubst (fn n => if n < k then NONE else SOME ((n-k, []), NONE))
ziv@2271 747
ziv@2271 748 fun unbind (qs, ub) =
ziv@2271 749 case ub of
ziv@2271 750 (* Shortcut if nothing's changing. *)
ziv@2271 751 Unknowns 0 => SOME qs
ziv@2273 752 | _ => osequence (map (fn (q, subst) => unbind1 ub subst
ziv@2273 753 <\obind\>
ziv@2273 754 (fn subst' => SOME (q, subst'))) qs)
ziv@2271 755
ziv@2273 756 fun updateState (qs, numArgs, state as {index, ...} : state) =
ziv@2273 757 {tableToIndices = List.foldr (fn ((q, _), acc) =>
ziv@2271 758 SS.foldl (fn (tab, acc) =>
ziv@2271 759 SIMM.insert (acc, tab, index))
ziv@2271 760 acc
ziv@2271 761 (tablesOfQuery q))
ziv@2271 762 (#tableToIndices state)
ziv@2271 763 qs,
ziv@2271 764 indexToInvalInfo = IM.insert (#indexToInvalInfo state, index, (qs, numArgs)),
ziv@2271 765 ffiInfo = {index = index, params = numArgs} :: #ffiInfo state,
ziv@2271 766 index = index + 1}
ziv@2271 767
ziv@2271 768 end
ziv@2271 769
ziv@2216 770 structure UF = UnionFindFn(AtomExpKey)
ziv@2234 771
ziv@2273 772 val rec sqexpToFormula =
ziv@2273 773 fn Sql.SqTrue => Combo (Conj, [])
ziv@2273 774 | Sql.SqFalse => Combo (Disj, [])
ziv@2273 775 | Sql.SqNot e => Negate (sqexpToFormula e)
ziv@2273 776 | Sql.Binop (Sql.RCmp c, e1, e2) => Atom (c, e1, e2)
ziv@2273 777 | Sql.Binop (Sql.RLop l, p1, p2) => Combo (case l of Sql.And => Conj | Sql.Or => Disj,
ziv@2273 778 [sqexpToFormula p1, sqexpToFormula p2])
ziv@2289 779 | e as Sql.Field f => Atom (Sql.Eq, e, Sql.SqTrue)
ziv@2273 780 (* ASK: any other sqexps that can be props? *)
ziv@2289 781 | Sql.SqConst prim =>
ziv@2289 782 (case prim of
ziv@2289 783 (Prim.String (Prim.Normal, s)) =>
ziv@2289 784 if s = #trueString (Settings.currentDbms ())
ziv@2289 785 then Combo (Conj, [])
ziv@2289 786 else if s = #falseString (Settings.currentDbms ())
ziv@2289 787 then Combo (Disj, [])
ziv@2289 788 else raise Fail "Sqlcache: sqexpToFormula (SqConst a)"
ziv@2289 789 | _ => raise Fail "Sqlcache: sqexpToFormula (SqConst b)")
ziv@2289 790 | Sql.Computed _ => raise Fail "Sqlcache: sqexpToFormula (Computed)"
ziv@2289 791 | Sql.SqKnown _ => raise Fail "Sqlcache: sqexpToFormula (SqKnown)"
ziv@2289 792 | Sql.Inj _ => raise Fail "Sqlcache: sqexpToFormula (Inj)"
ziv@2289 793 | Sql.SqFunc _ => raise Fail "Sqlcache: sqexpToFormula (SqFunc)"
ziv@2289 794 | Sql.Unmodeled => raise Fail "Sqlcache: sqexpToFormula (Unmodeled)"
ziv@2289 795 | Sql.Null => raise Fail "Sqlcache: sqexpToFormula (Null)"
ziv@2273 796
ziv@2275 797 fun mapSqexpFields f =
ziv@2294 798 fn Sql.Field (t, v) => f (t, v)
ziv@2275 799 | Sql.SqNot e => Sql.SqNot (mapSqexpFields f e)
ziv@2275 800 | Sql.Binop (r, e1, e2) => Sql.Binop (r, mapSqexpFields f e1, mapSqexpFields f e2)
ziv@2275 801 | Sql.SqKnown e => Sql.SqKnown (mapSqexpFields f e)
ziv@2275 802 | Sql.SqFunc (s, e) => Sql.SqFunc (s, mapSqexpFields f e)
ziv@2275 803 | e => e
ziv@2275 804
ziv@2273 805 fun renameTables tablePairs =
ziv@2273 806 let
ziv@2275 807 fun rename table =
ziv@2273 808 case List.find (fn (_, t) => table = t) tablePairs of
ziv@2273 809 NONE => table
ziv@2273 810 | SOME (realTable, _) => realTable
ziv@2273 811 in
ziv@2275 812 mapSqexpFields (fn (t, f) => Sql.Field (rename t, f))
ziv@2273 813 end
ziv@2273 814
ziv@2294 815 structure FlattenQuery = struct
ziv@2294 816
ziv@2294 817 datatype substitution = RenameTable of string | SubstituteExp of Sql.sqexp SM.map
ziv@2294 818
ziv@2294 819 fun applySubst substTable =
ziv@2294 820 let
ziv@2294 821 fun substitute (table, field) =
ziv@2294 822 case SM.find (substTable, table) of
ziv@2294 823 NONE => Sql.Field (table, field)
ziv@2294 824 | SOME (RenameTable realTable) => Sql.Field (realTable, field)
ziv@2294 825 | SOME (SubstituteExp substField) =>
ziv@2294 826 case SM.find (substField, field) of
ziv@2294 827 NONE => raise Fail "Sqlcache: applySubst"
ziv@2294 828 | SOME se => se
ziv@2294 829 in
ziv@2294 830 mapSqexpFields substitute
ziv@2294 831 end
ziv@2294 832
ziv@2294 833 fun addToSubst (substTable, table, substField) =
ziv@2294 834 SM.insert (substTable,
ziv@2294 835 table,
ziv@2294 836 case substField of
ziv@2294 837 RenameTable _ => substField
ziv@2294 838 | SubstituteExp subst => SubstituteExp (SM.map (applySubst substTable) subst))
ziv@2294 839
ziv@2294 840 fun newSubst (t, s) = addToSubst (SM.empty, t, s)
ziv@2294 841
ziv@2294 842 datatype sitem' = Named of Sql.sqexp * string | Unnamed of Sql.sqexp
ziv@2294 843
ziv@2294 844 type queryFlat = {Select : sitem' list, Where : Sql.sqexp}
ziv@2294 845
ziv@2294 846 val sitemsToSubst =
ziv@2294 847 List.foldl (fn (Named (se, s), acc) => SM.insert (acc, s, se)
ziv@2294 848 | (Unnamed _, _) => raise Fail "Sqlcache: sitemsToSubst")
ziv@2294 849 SM.empty
ziv@2294 850
ziv@2294 851 fun unionSubst (s1, s2) = SM.unionWith (fn _ => raise Fail "Sqlcache: unionSubst") (s1, s2)
ziv@2294 852
ziv@2294 853 fun sqlAnd (se1, se2) = Sql.Binop (Sql.RLop Sql.And, se1, se2)
ziv@2294 854
ziv@2294 855 val rec flattenFitem : Sql.fitem -> (Sql.sqexp * substitution SM.map) list =
ziv@2294 856 fn Sql.Table (real, alias) => [(Sql.SqTrue, newSubst (alias, RenameTable real))]
ziv@2294 857 | Sql.Nested (q, s) =>
ziv@2294 858 let
ziv@2294 859 val qfs = flattenQuery q
ziv@2294 860 in
ziv@2294 861 map (fn (qf, subst) =>
ziv@2294 862 (#Where qf, addToSubst (subst, s, SubstituteExp (sitemsToSubst (#Select qf)))))
ziv@2294 863 qfs
ziv@2294 864 end
ziv@2294 865 | Sql.Join (jt, fi1, fi2, se) =>
ziv@2294 866 concatMap (fn ((wher1, subst1)) =>
ziv@2294 867 map (fn (wher2, subst2) =>
ziv@2295 868 let
ziv@2295 869 val subst = unionSubst (subst1, subst2)
ziv@2295 870 in
ziv@2295 871 (* ON clause becomes part of the accumulated WHERE. *)
ziv@2295 872 (sqlAnd (sqlAnd (wher1, wher2), applySubst subst se), subst)
ziv@2295 873 end)
ziv@2294 874 (flattenFitem fi2))
ziv@2294 875 (flattenFitem fi1)
ziv@2294 876
ziv@2294 877 and flattenQuery : Sql.query -> (queryFlat * substitution SM.map) list =
ziv@2294 878 fn Sql.Query1 q =>
ziv@2294 879 let
ziv@2294 880 val fifss = cartesianProduct (map flattenFitem (#From q))
ziv@2294 881 in
ziv@2294 882 map (fn fifs =>
ziv@2294 883 let
ziv@2294 884 val subst = List.foldl (fn ((_, subst), acc) => unionSubst (acc, subst))
ziv@2294 885 SM.empty
ziv@2294 886 fifs
ziv@2294 887 val wher = List.foldr (fn ((wher, _), acc) => sqlAnd (wher, acc))
ziv@2294 888 (case #Where q of
ziv@2294 889 NONE => Sql.SqTrue
ziv@2294 890 | SOME wher => wher)
ziv@2294 891 fifs
ziv@2294 892 in
ziv@2294 893 (* ASK: do we actually need to pass the substitution through here? *)
ziv@2294 894 (* We use the substitution later, but it's not clear we
ziv@2294 895 need any of its currently present fields again. *)
ziv@2294 896 ({Select = map (fn Sql.SqExp (se, s) => Named (applySubst subst se, s)
ziv@2294 897 | Sql.SqField tf =>
ziv@2294 898 Unnamed (applySubst subst (Sql.Field tf)))
ziv@2294 899 (#Select q),
ziv@2294 900 Where = applySubst subst wher},
ziv@2294 901 subst)
ziv@2294 902 end)
ziv@2294 903 fifss
ziv@2294 904 end
ziv@2294 905 | Sql.Union (q1, q2) => (flattenQuery q1) @ (flattenQuery q2)
ziv@2294 906
ziv@2294 907 end
ziv@2294 908
ziv@2294 909 val flattenQuery = map #1 o FlattenQuery.flattenQuery
ziv@2294 910
ziv@2294 911 fun queryFlatToFormula marker {Select = sitems, Where = wher} =
ziv@2274 912 let
ziv@2294 913 val fWhere = sqexpToFormula wher
ziv@2274 914 in
ziv@2275 915 case marker of
ziv@2275 916 NONE => fWhere
ziv@2275 917 | SOME markFields =>
ziv@2275 918 let
ziv@2275 919 val fWhereMarked = mapFormulaExps markFields fWhere
ziv@2275 920 val toSqexp =
ziv@2294 921 fn FlattenQuery.Named (se, _) => se
ziv@2294 922 | FlattenQuery.Unnamed se => se
ziv@2275 923 fun ineq se = Atom (Sql.Ne, se, markFields se)
ziv@2294 924 val fIneqs = Combo (Disj, map (ineq o toSqexp) sitems)
ziv@2275 925 in
ziv@2275 926 (Combo (Conj,
ziv@2275 927 [fWhere,
ziv@2275 928 Combo (Disj,
ziv@2275 929 [Negate fWhereMarked,
ziv@2275 930 Combo (Conj, [fWhereMarked, fIneqs])])]))
ziv@2275 931 end
ziv@2274 932 end
ziv@2294 933
ziv@2294 934 fun queryToFormula marker q = Combo (Disj, map (queryFlatToFormula marker) (flattenQuery q))
ziv@2273 935
ziv@2274 936 fun valsToFormula (markLeft, markRight) (table, vals) =
ziv@2274 937 Combo (Conj,
ziv@2274 938 map (fn (field, v) => Atom (Sql.Eq, markLeft (Sql.Field (table, field)), markRight v))
ziv@2274 939 vals)
ziv@2273 940
ziv@2274 941 (* TODO: verify logic for insertion and deletion. *)
ziv@2274 942 val rec dmlToFormulaMarker =
ziv@2274 943 fn Sql.Insert (table, vals) => (valsToFormula (id, id) (table, vals), NONE)
ziv@2275 944 | Sql.Delete (table, wher) => (sqexpToFormula (renameTables [(table, "T")] wher), NONE)
ziv@2273 945 | Sql.Update (table, vals, wher) =>
ziv@2273 946 let
ziv@2275 947 val fWhere = sqexpToFormula (renameTables [(table, "T")] wher)
ziv@2274 948 fun fVals marks = valsToFormula marks (table, vals)
ziv@2273 949 val modifiedFields = SS.addList (SS.empty, map #1 vals)
ziv@2273 950 (* TODO: don't use field name hack. *)
ziv@2275 951 val markFields =
ziv@2275 952 mapSqexpFields (fn (t, v) => if t = table andalso SS.member (modifiedFields, v)
ziv@2276 953 then Sql.Field (t, v ^ "'")
ziv@2276 954 else Sql.Field (t, v))
ziv@2275 955 val mark = mapFormulaExps markFields
ziv@2273 956 in
ziv@2275 957 ((Combo (Disj, [Combo (Conj, [fVals (id, markFields), mark fWhere]),
ziv@2275 958 Combo (Conj, [fVals (markFields, id), fWhere])])),
ziv@2275 959 SOME markFields)
ziv@2273 960 end
ziv@2273 961
ziv@2274 962 fun pairToFormulas (query, dml) =
ziv@2274 963 let
ziv@2276 964 val (fDml, marker) = dmlToFormulaMarker dml
ziv@2274 965 in
ziv@2274 966 (queryToFormula marker query, fDml)
ziv@2274 967 end
ziv@2274 968
ziv@2235 969 structure ConflictMaps = struct
ziv@2235 970
ziv@2235 971 structure TK = TripleKeyFn(structure I = CmpKey
ziv@2244 972 structure J = AtomOptionKey
ziv@2244 973 structure K = AtomOptionKey)
ziv@2274 974
ziv@2244 975 structure TS : ORD_SET = BinarySetFn(TK)
ziv@2235 976
ziv@2235 977 val toKnownEquality =
ziv@2235 978 (* [NONE] here means unkown. Anything that isn't a comparison between two
ziv@2235 979 knowns shouldn't be used, and simply dropping unused terms is okay in
ziv@2235 980 disjunctive normal form. *)
ziv@2235 981 fn (Sql.Eq, SOME e1, SOME e2) => SOME (e1, e2)
ziv@2235 982 | _ => NONE
ziv@2235 983
ziv@2274 984 fun equivClasses atoms : atomExp list list option =
ziv@2274 985 let
ziv@2274 986 val uf = List.foldl UF.union' UF.empty (List.mapPartial toKnownEquality atoms)
ziv@2274 987 val contradiction =
ziv@2274 988 fn (cmp, SOME ae1, SOME ae2) => (cmp = Sql.Ne orelse cmp = Sql.Lt orelse cmp = Sql.Gt)
ziv@2275 989 andalso UF.together (uf, ae1, ae2)
ziv@2274 990 (* If we don't know one side of the comparision, not a contradiction. *)
ziv@2274 991 | _ => false
ziv@2274 992 in
ziv@2294 993 not (List.exists contradiction atoms) <\oguard\> (fn _ => SOME (UF.classes uf))
ziv@2274 994 end
ziv@2235 995
ziv@2235 996 fun addToEqs (eqs, n, e) =
ziv@2235 997 case IM.find (eqs, n) of
ziv@2235 998 (* Comparing to a constant is probably better than comparing to a
ziv@2235 999 variable? Checking that existing constants match a new ones is
ziv@2235 1000 handled by [accumulateEqs]. *)
ziv@2235 1001 SOME (Prim _) => eqs
ziv@2235 1002 | _ => IM.insert (eqs, n, e)
ziv@2235 1003
ziv@2235 1004 val accumulateEqs =
ziv@2235 1005 (* [NONE] means we have a contradiction. *)
ziv@2235 1006 fn (_, NONE) => NONE
ziv@2235 1007 | ((Prim p1, Prim p2), eqso) =>
ziv@2235 1008 (case Prim.compare (p1, p2) of
ziv@2235 1009 EQUAL => eqso
ziv@2235 1010 | _ => NONE)
ziv@2235 1011 | ((QueryArg n, Prim p), SOME eqs) => SOME (addToEqs (eqs, n, Prim p))
ziv@2235 1012 | ((QueryArg n, DmlRel r), SOME eqs) => SOME (addToEqs (eqs, n, DmlRel r))
ziv@2235 1013 | ((Prim p, QueryArg n), SOME eqs) => SOME (addToEqs (eqs, n, Prim p))
ziv@2235 1014 | ((DmlRel r, QueryArg n), SOME eqs) => SOME (addToEqs (eqs, n, DmlRel r))
ziv@2235 1015 (* TODO: deal with equalities between [DmlRel]s and [Prim]s.
ziv@2235 1016 This would involve guarding the invalidation with a check for the
ziv@2235 1017 relevant comparisons. *)
ziv@2235 1018 | (_, eqso) => eqso
ziv@2235 1019
ziv@2235 1020 val eqsOfClass : atomExp list -> atomExp IM.map option =
ziv@2235 1021 List.foldl accumulateEqs (SOME IM.empty)
ziv@2235 1022 o chooseTwos
ziv@2235 1023
ziv@2235 1024 fun toAtomExps rel (cmp, e1, e2) =
ziv@2235 1025 let
ziv@2235 1026 val qa =
ziv@2235 1027 (* Here [NONE] means unkown. *)
ziv@2235 1028 fn Sql.SqConst p => SOME (Prim p)
ziv@2235 1029 | Sql.Field tf => SOME (Field tf)
ziv@2235 1030 | Sql.Inj (EPrim p, _) => SOME (Prim p)
ziv@2235 1031 | Sql.Inj (ERel n, _) => SOME (rel n)
ziv@2235 1032 (* We can't deal with anything else, e.g., CURRENT_TIMESTAMP
ziv@2235 1033 becomes Sql.Unmodeled, which becomes NONE here. *)
ziv@2235 1034 | _ => NONE
ziv@2235 1035 in
ziv@2235 1036 (cmp, qa e1, qa e2)
ziv@2235 1037 end
ziv@2235 1038
ziv@2244 1039 val negateCmp =
ziv@2244 1040 fn Sql.Eq => Sql.Ne
ziv@2244 1041 | Sql.Ne => Sql.Eq
ziv@2244 1042 | Sql.Lt => Sql.Ge
ziv@2244 1043 | Sql.Le => Sql.Gt
ziv@2244 1044 | Sql.Gt => Sql.Le
ziv@2244 1045 | Sql.Ge => Sql.Lt
ziv@2244 1046
ziv@2244 1047 fun normalizeAtom (negating, (cmp, e1, e2)) =
ziv@2244 1048 (* Restricting to Le/Lt and sorting the expressions in Eq/Ne helps with
ziv@2244 1049 simplification, where we put the triples in sets. *)
ziv@2244 1050 case (if negating then negateCmp cmp else cmp) of
ziv@2244 1051 Sql.Eq => (case AtomOptionKey.compare (e1, e2) of
ziv@2244 1052 LESS => (Sql.Eq, e2, e1)
ziv@2244 1053 | _ => (Sql.Eq, e1, e2))
ziv@2244 1054 | Sql.Ne => (case AtomOptionKey.compare (e1, e2) of
ziv@2244 1055 LESS => (Sql.Ne, e2, e1)
ziv@2244 1056 | _ => (Sql.Ne, e1, e2))
ziv@2244 1057 | Sql.Lt => (Sql.Lt, e1, e2)
ziv@2244 1058 | Sql.Le => (Sql.Le, e1, e2)
ziv@2244 1059 | Sql.Gt => (Sql.Lt, e2, e1)
ziv@2244 1060 | Sql.Ge => (Sql.Le, e2, e1)
ziv@2235 1061
ziv@2235 1062 val markQuery : (Sql.cmp * Sql.sqexp * Sql.sqexp) formula ->
ziv@2235 1063 (Sql.cmp * atomExp option * atomExp option) formula =
ziv@2235 1064 mapFormula (toAtomExps QueryArg)
ziv@2235 1065
ziv@2235 1066 val markDml : (Sql.cmp * Sql.sqexp * Sql.sqexp) formula ->
ziv@2235 1067 (Sql.cmp * atomExp option * atomExp option) formula =
ziv@2235 1068 mapFormula (toAtomExps DmlRel)
ziv@2250 1069
ziv@2235 1070 (* No eqs should have key conflicts because no variable is in two
ziv@2294 1071 equivalence classes. *)
ziv@2235 1072 val mergeEqs : (atomExp IntBinaryMap.map option list
ziv@2235 1073 -> atomExp IntBinaryMap.map option) =
ziv@2294 1074 List.foldr (omap2 (IM.unionWith (fn _ => raise Fail "Sqlcache: ConflictMaps.mergeEqs")))
ziv@2294 1075 (SOME IM.empty)
ziv@2235 1076
ziv@2239 1077 val simplify =
ziv@2239 1078 map TS.listItems
ziv@2239 1079 o removeRedundant (fn (x, y) => TS.isSubset (y, x))
ziv@2239 1080 o map (fn xs => TS.addList (TS.empty, xs))
ziv@2239 1081
ziv@2235 1082 fun dnf (fQuery, fDml) =
ziv@2244 1083 normalize simplify normalizeAtom Disj (Combo (Conj, [markQuery fQuery, markDml fDml]))
ziv@2235 1084
ziv@2274 1085 val conflictMaps =
ziv@2274 1086 List.mapPartial (mergeEqs o map eqsOfClass)
ziv@2274 1087 o List.mapPartial equivClasses
ziv@2274 1088 o dnf
ziv@2235 1089
ziv@2235 1090 end
ziv@2235 1091
ziv@2235 1092 val conflictMaps = ConflictMaps.conflictMaps
ziv@2213 1093
ziv@2213 1094
ziv@2265 1095 (*************************************)
ziv@2265 1096 (* Program Instrumentation Utilities *)
ziv@2265 1097 (*************************************)
ziv@2213 1098
ziv@2288 1099 val {check, store, flush, lock, ...} = getCache ()
ziv@2233 1100
ziv@2248 1101 val dummyTyp = (TRecord [], dummyLoc)
ziv@2248 1102
ziv@2230 1103 fun stringExp s = (EPrim (Prim.String (Prim.Normal, s)), dummyLoc)
ziv@2230 1104
ziv@2230 1105 val stringTyp = (TFfi ("Basis", "string"), dummyLoc)
ziv@2213 1106
ziv@2213 1107 val sequence =
ziv@2213 1108 fn (exp :: exps) =>
ziv@2213 1109 let
ziv@2230 1110 val loc = dummyLoc
ziv@2213 1111 in
ziv@2213 1112 List.foldl (fn (e', seq) => ESeq ((seq, loc), (e', loc))) exp exps
ziv@2213 1113 end
ziv@2289 1114 | _ => raise Fail "Sqlcache: sequence"
ziv@2213 1115
ziv@2248 1116 (* Always increments negative indices as a hack we use later. *)
ziv@2248 1117 fun incRels inc =
ziv@2215 1118 MonoUtil.Exp.mapB
ziv@2248 1119 {typ = fn t' => t',
ziv@2248 1120 exp = fn bound =>
ziv@2248 1121 (fn ERel n => ERel (if n >= bound orelse n < 0 then n + inc else n)
ziv@2248 1122 | e' => e'),
ziv@2248 1123 bind = fn (bound, MonoUtil.Exp.RelE _) => bound + 1 | (bound, _) => bound}
ziv@2248 1124 0
ziv@2213 1125
ziv@2262 1126 fun fileTopLevelMapfoldB doTopLevelExp (decls, sideInfo) state =
ziv@2262 1127 let
ziv@2262 1128 fun doVal env ((x, n, t, exp, s), state) =
ziv@2262 1129 let
ziv@2262 1130 val (exp, state) = doTopLevelExp env exp state
ziv@2262 1131 in
ziv@2262 1132 ((x, n, t, exp, s), state)
ziv@2262 1133 end
ziv@2262 1134 fun doDecl' env (decl', state) =
ziv@2262 1135 case decl' of
ziv@2262 1136 DVal v =>
ziv@2262 1137 let
ziv@2262 1138 val (v, state) = doVal env (v, state)
ziv@2262 1139 in
ziv@2262 1140 (DVal v, state)
ziv@2262 1141 end
ziv@2262 1142 | DValRec vs =>
ziv@2262 1143 let
ziv@2262 1144 val (vs, state) = ListUtil.foldlMap (doVal env) state vs
ziv@2262 1145 in
ziv@2262 1146 (DValRec vs, state)
ziv@2262 1147 end
ziv@2262 1148 | _ => (decl', state)
ziv@2262 1149 fun doDecl (decl as (decl', loc), (env, state)) =
ziv@2262 1150 let
ziv@2262 1151 val env = MonoEnv.declBinds env decl
ziv@2262 1152 val (decl', state) = doDecl' env (decl', state)
ziv@2262 1153 in
ziv@2262 1154 ((decl', loc), (env, state))
ziv@2262 1155 end
ziv@2262 1156 val (decls, (_, state)) = (ListUtil.foldlMap doDecl (MonoEnv.empty, state) decls)
ziv@2262 1157 in
ziv@2262 1158 ((decls, sideInfo), state)
ziv@2262 1159 end
ziv@2262 1160
ziv@2262 1161 fun fileAllMapfoldB doExp file start =
ziv@2248 1162 case MonoUtil.File.mapfoldB
ziv@2248 1163 {typ = Search.return2,
ziv@2250 1164 exp = fn env => fn e' => fn s => Search.Continue (doExp env e' s),
ziv@2248 1165 decl = fn _ => Search.return2,
ziv@2248 1166 bind = doBind}
ziv@2250 1167 MonoEnv.empty file start of
ziv@2213 1168 Search.Continue x => x
ziv@2289 1169 | Search.Return _ => raise Fail "Sqlcache: fileAllMapfoldB"
ziv@2213 1170
ziv@2262 1171 fun fileMap doExp file = #1 (fileAllMapfoldB (fn _ => fn e => fn _ => (doExp e, ())) file ())
ziv@2213 1172
ziv@2267 1173 (* TODO: make this a bit prettier.... *)
ziv@2294 1174 (* TODO: factour out identical subexpressions to the same variable.... *)
ziv@2267 1175 val simplifySql =
ziv@2266 1176 let
ziv@2267 1177 fun factorOutNontrivial text =
ziv@2267 1178 let
ziv@2267 1179 val loc = dummyLoc
ziv@2294 1180 val strcat =
ziv@2294 1181 fn (e1, (EPrim (Prim.String (Prim.Normal, "")), _)) => e1
ziv@2294 1182 | ((EPrim (Prim.String (Prim.Normal, "")), _), e2) => e2
ziv@2294 1183 | (e1, e2) => (EStrcat (e1, e2), loc)
ziv@2267 1184 val chunks = Sql.chunkify text
ziv@2267 1185 val (newText, newVariables) =
ziv@2267 1186 (* Important that this is foldr (to oppose foldl below). *)
ziv@2267 1187 List.foldr
ziv@2267 1188 (fn (chunk, (qText, newVars)) =>
ziv@2267 1189 (* Variable bound to the head of newVars will have the lowest index. *)
ziv@2267 1190 case chunk of
ziv@2267 1191 (* EPrim should always be a string in this case. *)
ziv@2267 1192 Sql.Exp (e as (EPrim _, _)) => (strcat (e, qText), newVars)
ziv@2267 1193 | Sql.Exp e =>
ziv@2267 1194 let
ziv@2267 1195 val n = length newVars
ziv@2267 1196 in
ziv@2267 1197 (* This is the (n+1)th new variable, so there are
ziv@2267 1198 already n new variables bound, so we increment
ziv@2267 1199 indices by n. *)
ziv@2267 1200 (strcat ((ERel (~(n+1)), loc), qText), incRels n e :: newVars)
ziv@2267 1201 end
ziv@2267 1202 | Sql.String s => (strcat (stringExp s, qText), newVars))
ziv@2267 1203 (stringExp "", [])
ziv@2267 1204 chunks
ziv@2267 1205 fun wrapLets e' =
ziv@2267 1206 (* Important that this is foldl (to oppose foldr above). *)
ziv@2273 1207 List.foldl (fn (v, e') => ELet ("sqlArg", stringTyp, v, (e', loc)))
ziv@2267 1208 e'
ziv@2267 1209 newVariables
ziv@2267 1210 val numArgs = length newVariables
ziv@2267 1211 in
ziv@2267 1212 (newText, wrapLets, numArgs)
ziv@2267 1213 end
ziv@2267 1214 fun doExp exp' =
ziv@2267 1215 let
ziv@2267 1216 val text = case exp' of
ziv@2267 1217 EQuery {query = text, ...} => text
ziv@2267 1218 | EDml (text, _) => text
ziv@2289 1219 | _ => raise Fail "Sqlcache: simplifySql (a)"
ziv@2267 1220 val (newText, wrapLets, numArgs) = factorOutNontrivial text
ziv@2267 1221 val newExp' = case exp' of
ziv@2267 1222 EQuery q => EQuery {query = newText,
ziv@2267 1223 exps = #exps q,
ziv@2267 1224 tables = #tables q,
ziv@2267 1225 state = #state q,
ziv@2267 1226 body = #body q,
ziv@2267 1227 initial = #initial q}
ziv@2267 1228 | EDml (_, failureMode) => EDml (newText, failureMode)
ziv@2289 1229 | _ => raise Fail "Sqlcache: simplifySql (b)"
ziv@2267 1230 in
ziv@2267 1231 (* Increment once for each new variable just made. This is
ziv@2267 1232 where we use the negative De Bruijn indices hack. *)
ziv@2267 1233 (* TODO: please don't use that hack. As anyone could have
ziv@2267 1234 predicted, it was incomprehensible a year later.... *)
ziv@2267 1235 wrapLets (#1 (incRels numArgs (newExp', dummyLoc)))
ziv@2267 1236 end
ziv@2266 1237 in
ziv@2267 1238 fileMap (fn exp' => case exp' of
ziv@2267 1239 EQuery _ => doExp exp'
ziv@2267 1240 | EDml _ => doExp exp'
ziv@2267 1241 | _ => exp')
ziv@2266 1242 end
ziv@2266 1243
ziv@2250 1244
ziv@2250 1245 (**********************)
ziv@2250 1246 (* Mono Type Checking *)
ziv@2250 1247 (**********************)
ziv@2250 1248
ziv@2250 1249 fun typOfExp' (env : MonoEnv.env) : exp' -> typ option =
ziv@2250 1250 fn EPrim p => SOME (TFfi ("Basis", case p of
ziv@2250 1251 Prim.Int _ => "int"
ziv@2250 1252 | Prim.Float _ => "double"
ziv@2250 1253 | Prim.String _ => "string"
ziv@2250 1254 | Prim.Char _ => "char"),
ziv@2250 1255 dummyLoc)
ziv@2250 1256 | ERel n => SOME (#2 (MonoEnv.lookupERel env n))
ziv@2250 1257 | ENamed n => SOME (#2 (MonoEnv.lookupENamed env n))
ziv@2250 1258 (* ASK: okay to make a new [ref] each time? *)
ziv@2250 1259 | ECon (dk, PConVar nCon, _) =>
ziv@2250 1260 let
ziv@2250 1261 val (_, _, nData) = MonoEnv.lookupConstructor env nCon
ziv@2250 1262 val (_, cs) = MonoEnv.lookupDatatype env nData
ziv@2250 1263 in
ziv@2250 1264 SOME (TDatatype (nData, ref (dk, cs)), dummyLoc)
ziv@2250 1265 end
ziv@2250 1266 | ECon (_, PConFfi {mod = s, datatyp, ...}, _) => SOME (TFfi (s, datatyp), dummyLoc)
ziv@2250 1267 | ENone t => SOME (TOption t, dummyLoc)
ziv@2250 1268 | ESome (t, _) => SOME (TOption t, dummyLoc)
ziv@2250 1269 | EFfi _ => NONE
ziv@2250 1270 | EFfiApp _ => NONE
ziv@2250 1271 | EApp (e1, e2) => (case typOfExp env e1 of
ziv@2250 1272 SOME (TFun (_, t), _) => SOME t
ziv@2250 1273 | _ => NONE)
ziv@2250 1274 | EAbs (_, t1, t2, _) => SOME (TFun (t1, t2), dummyLoc)
ziv@2250 1275 (* ASK: is this right? *)
ziv@2250 1276 | EUnop (unop, e) => (case unop of
ziv@2250 1277 "!" => SOME (TFfi ("Basis", "bool"), dummyLoc)
ziv@2250 1278 | "-" => typOfExp env e
ziv@2250 1279 | _ => NONE)
ziv@2250 1280 (* ASK: how should this (and other "=> NONE" cases) work? *)
ziv@2250 1281 | EBinop _ => NONE
ziv@2250 1282 | ERecord fields => SOME (TRecord (map (fn (s, _, t) => (s, t)) fields), dummyLoc)
ziv@2250 1283 | EField (e, s) => (case typOfExp env e of
ziv@2250 1284 SOME (TRecord fields, _) =>
ziv@2286 1285 omap #2 (List.find (fn (s', _) => s = s') fields)
ziv@2250 1286 | _ => NONE)
ziv@2250 1287 | ECase (_, _, {result, ...}) => SOME result
ziv@2250 1288 | EStrcat _ => SOME (TFfi ("Basis", "string"), dummyLoc)
ziv@2250 1289 | EWrite _ => SOME (TRecord [], dummyLoc)
ziv@2250 1290 | ESeq (_, e) => typOfExp env e
ziv@2250 1291 | ELet (s, t, e1, e2) => typOfExp (MonoEnv.pushERel env s t (SOME e1)) e2
ziv@2250 1292 | EClosure _ => NONE
ziv@2250 1293 | EUnurlify (_, t, _) => SOME t
ziv@2269 1294 | EQuery {state, ...} => SOME state
ziv@2276 1295 | e => NONE
ziv@2250 1296
ziv@2250 1297 and typOfExp env (e', loc) = typOfExp' env e'
ziv@2250 1298
ziv@2250 1299
ziv@2266 1300 (***********)
ziv@2266 1301 (* Caching *)
ziv@2266 1302 (***********)
ziv@2250 1303
ziv@2271 1304 type state = InvalInfo.state
ziv@2271 1305
ziv@2271 1306 datatype subexp = Cachable of InvalInfo.t * (state -> exp * state) | Impure of exp
ziv@2271 1307
ziv@2271 1308 val isImpure =
ziv@2271 1309 fn Cachable _ => false
ziv@2271 1310 | Impure _ => true
ziv@2271 1311
ziv@2271 1312 val runSubexp : subexp * state -> exp * state =
ziv@2271 1313 fn (Cachable (_, f), state) => f state
ziv@2271 1314 | (Impure e, state) => (e, state)
ziv@2271 1315
ziv@2271 1316 val invalInfoOfSubexp =
ziv@2271 1317 fn Cachable (invalInfo, _) => invalInfo
ziv@2289 1318 | Impure _ => raise Fail "Sqlcache: invalInfoOfSubexp"
ziv@2271 1319
ziv@2271 1320 fun cacheWrap (env, exp, typ, args, index) =
ziv@2265 1321 let
ziv@2265 1322 val loc = dummyLoc
ziv@2265 1323 val rel0 = (ERel 0, loc)
ziv@2265 1324 in
ziv@2271 1325 case MonoFooify.urlify env (rel0, typ) of
ziv@2265 1326 NONE => NONE
ziv@2265 1327 | SOME urlified =>
ziv@2265 1328 let
ziv@2265 1329 (* We ensure before this step that all arguments aren't effectful.
ziv@2265 1330 by turning them into local variables as needed. *)
ziv@2265 1331 val argsInc = map (incRels 1) args
ziv@2268 1332 val check = (check (index, args), loc)
ziv@2268 1333 val store = (store (index, argsInc, urlified), loc)
ziv@2265 1334 in
ziv@2271 1335 SOME (ECase (check,
ziv@2271 1336 [((PNone stringTyp, loc),
ziv@2273 1337 (ELet ("q", typ, exp, (ESeq (store, rel0), loc)), loc)),
ziv@2273 1338 ((PSome (stringTyp, (PVar ("hit", stringTyp), loc)), loc),
ziv@2271 1339 (* Boolean is false because we're not unurlifying from a cookie. *)
ziv@2271 1340 (EUnurlify (rel0, typ, false), loc))],
ziv@2271 1341 {disc = (TOption stringTyp, loc), result = typ}))
ziv@2265 1342 end
ziv@2265 1343 end
ziv@2265 1344
ziv@2258 1345 val expSize = MonoUtil.Exp.fold {typ = #2, exp = fn (_, n) => n+1} 0
ziv@2258 1346
ziv@2259 1347 (* TODO: pick a number. *)
ziv@2278 1348 val sizeWorthCaching = 5
ziv@2259 1349
ziv@2269 1350 val worthCaching =
ziv@2269 1351 fn EQuery _ => true
ziv@2269 1352 | exp' => expSize (exp', dummyLoc) > sizeWorthCaching
ziv@2269 1353
ziv@2273 1354 fun cacheExp (env, exp', invalInfo, state : state) =
ziv@2294 1355 case worthCaching exp' <\oguard\> (fn _ => typOfExp' env exp') of
ziv@2269 1356 NONE => NONE
ziv@2269 1357 | SOME (TFun _, _) => NONE
ziv@2269 1358 | SOME typ =>
ziv@2299 1359 InvalInfo.orderArgs (invalInfo, (exp', dummyLoc))
ziv@2299 1360 <\obind\>
ziv@2299 1361 (fn args =>
ziv@2299 1362 List.foldr (fn (arg, acc) =>
ziv@2299 1363 acc
ziv@2299 1364 <\obind\>
ziv@2299 1365 (fn args' =>
ziv@2299 1366 (case arg of
ziv@2299 1367 AsIs exp => SOME exp
ziv@2299 1368 | Urlify exp =>
ziv@2299 1369 typOfExp env exp
ziv@2299 1370 <\obind\>
ziv@2299 1371 (fn typ => (MonoFooify.urlify env (exp, typ))))
ziv@2299 1372 <\obind\>
ziv@2299 1373 (fn arg' => SOME (arg' :: args'))))
ziv@2299 1374 (SOME [])
ziv@2299 1375 args
ziv@2299 1376 <\obind\>
ziv@2299 1377 (fn args' =>
ziv@2299 1378 cacheWrap (env, (exp', dummyLoc), typ, args', #index state)
ziv@2299 1379 <\obind\>
ziv@2299 1380 (fn cachedExp =>
ziv@2299 1381 SOME (cachedExp,
ziv@2299 1382 InvalInfo.updateState (invalInfo, length args', state)))))
ziv@2269 1383
ziv@2271 1384 fun cacheQuery (effs, env, q) : subexp =
ziv@2266 1385 let
ziv@2266 1386 (* We use dummyTyp here. I think this is okay because databases don't
ziv@2266 1387 store (effectful) functions, but perhaps there's some pathalogical
ziv@2266 1388 corner case missing.... *)
ziv@2266 1389 fun safe bound =
ziv@2266 1390 not
ziv@2266 1391 o effectful effs
ziv@2266 1392 (iterate (fn env => MonoEnv.pushERel env "_" dummyTyp NONE)
ziv@2266 1393 bound
ziv@2266 1394 env)
ziv@2271 1395 val {query = queryText, initial, body, ...} = q
ziv@2266 1396 val attempt =
ziv@2266 1397 (* Ziv misses Haskell's do notation.... *)
ziv@2295 1398 (safe 0 queryText andalso safe 0 initial andalso safe 2 body)
ziv@2273 1399 <\oguard\>
ziv@2294 1400 (fn _ =>
ziv@2295 1401 Sql.parse Sql.query queryText
ziv@2294 1402 <\obind\>
ziv@2294 1403 (fn queryParsed =>
ziv@2294 1404 let
ziv@2294 1405 val invalInfo = InvalInfo.singleton queryParsed
ziv@2294 1406 fun mkExp state =
ziv@2294 1407 case cacheExp (env, EQuery q, invalInfo, state) of
ziv@2294 1408 NONE => ((EQuery q, dummyLoc), state)
ziv@2294 1409 | SOME (cachedExp, state) => ((cachedExp, dummyLoc), state)
ziv@2294 1410 in
ziv@2294 1411 SOME (Cachable (invalInfo, mkExp))
ziv@2294 1412 end))
ziv@2266 1413 in
ziv@2266 1414 case attempt of
ziv@2271 1415 NONE => Impure (EQuery q, dummyLoc)
ziv@2271 1416 | SOME subexp => subexp
ziv@2266 1417 end
ziv@2266 1418
ziv@2278 1419 fun cacheTree (effs : IS.set) ((env, exp as (exp', loc)), state) =
ziv@2250 1420 let
ziv@2271 1421 fun wrapBindN (f : exp list -> exp')
ziv@2271 1422 (args : ((MonoEnv.env * exp) * unbind) list) =
ziv@2250 1423 let
ziv@2271 1424 val (subexps, state) =
ziv@2271 1425 ListUtil.foldlMap (cacheTree effs)
ziv@2271 1426 state
ziv@2271 1427 (map #1 args)
ziv@2268 1428 fun mkExp state = mapFst (fn exps => (f exps, loc))
ziv@2268 1429 (ListUtil.foldlMap runSubexp state subexps)
ziv@2271 1430 val attempt =
ziv@2271 1431 if List.exists isImpure subexps
ziv@2271 1432 then NONE
ziv@2271 1433 else (List.foldl (omap2 InvalInfo.union)
ziv@2271 1434 (SOME InvalInfo.empty)
ziv@2271 1435 (ListPair.map
ziv@2271 1436 (fn (subexp, (_, unbinds)) =>
ziv@2271 1437 InvalInfo.unbind (invalInfoOfSubexp subexp, unbinds))
ziv@2271 1438 (subexps, args)))
ziv@2273 1439 <\obind\>
ziv@2294 1440 (fn invalInfo =>
ziv@2294 1441 SOME (Cachable (invalInfo,
ziv@2294 1442 fn state =>
ziv@2294 1443 case cacheExp (env,
ziv@2294 1444 f (map (#2 o #1) args),
ziv@2294 1445 invalInfo,
ziv@2294 1446 state) of
ziv@2294 1447 NONE => mkExp state
ziv@2294 1448 | SOME (e', state) => ((e', loc), state)),
ziv@2294 1449 state))
ziv@2250 1450 in
ziv@2271 1451 case attempt of
ziv@2271 1452 SOME (subexp, state) => (subexp, state)
ziv@2271 1453 | NONE => mapFst Impure (mkExp state)
ziv@2250 1454 end
ziv@2250 1455 fun wrapBind1 f arg =
ziv@2289 1456 wrapBindN (fn [arg] => f arg
ziv@2289 1457 | _ => raise Fail "Sqlcache: cacheTree (a)") [arg]
ziv@2250 1458 fun wrapBind2 f (arg1, arg2) =
ziv@2289 1459 wrapBindN (fn [arg1, arg2] => f (arg1, arg2)
ziv@2289 1460 | _ => raise Fail "Sqlcache: cacheTree (b)") [arg1, arg2]
ziv@2271 1461 fun wrapN f es = wrapBindN f (map (fn e => ((env, e), Unknowns 0)) es)
ziv@2271 1462 fun wrap1 f e = wrapBind1 f ((env, e), Unknowns 0)
ziv@2271 1463 fun wrap2 f (e1, e2) = wrapBind2 f (((env, e1), Unknowns 0), ((env, e2), Unknowns 0))
ziv@2250 1464 in
ziv@2250 1465 case exp' of
ziv@2250 1466 ECon (dk, pc, SOME e) => wrap1 (fn e => ECon (dk, pc, SOME e)) e
ziv@2250 1467 | ESome (t, e) => wrap1 (fn e => ESome (t, e)) e
ziv@2250 1468 | EFfiApp (s1, s2, args) =>
ziv@2258 1469 if ffiEffectful (s1, s2)
ziv@2266 1470 then (Impure exp, state)
ziv@2258 1471 else wrapN (fn es =>
ziv@2258 1472 EFfiApp (s1, s2, ListPair.map (fn (e, (_, t)) => (e, t)) (es, args)))
ziv@2258 1473 (map #1 args)
ziv@2250 1474 | EApp (e1, e2) => wrap2 EApp (e1, e2)
ziv@2250 1475 | EAbs (s, t1, t2, e) =>
ziv@2250 1476 wrapBind1 (fn e => EAbs (s, t1, t2, e))
ziv@2271 1477 ((MonoEnv.pushERel env s t1 NONE, e), Unknowns 1)
ziv@2250 1478 | EUnop (s, e) => wrap1 (fn e => EUnop (s, e)) e
ziv@2250 1479 | EBinop (bi, s, e1, e2) => wrap2 (fn (e1, e2) => EBinop (bi, s, e1, e2)) (e1, e2)
ziv@2250 1480 | ERecord fields =>
ziv@2250 1481 wrapN (fn es => ERecord (ListPair.map (fn (e, (s, _, t)) => (s, e, t)) (es, fields)))
ziv@2250 1482 (map #2 fields)
ziv@2250 1483 | EField (e, s) => wrap1 (fn e => EField (e, s)) e
ziv@2250 1484 | ECase (e, cases, {disc, result}) =>
ziv@2250 1485 wrapBindN (fn (e::es) =>
ziv@2250 1486 ECase (e,
ziv@2250 1487 (ListPair.map (fn (e, (p, _)) => (p, e)) (es, cases)),
ziv@2256 1488 {disc = disc, result = result})
ziv@2289 1489 | _ => raise Fail "Sqlcache: cacheTree (c)")
ziv@2271 1490 (((env, e), Unknowns 0)
ziv@2271 1491 :: map (fn (p, e) =>
ziv@2271 1492 ((MonoEnv.patBinds env p, e), Unknowns (MonoEnv.patBindsN p)))
ziv@2271 1493 cases)
ziv@2250 1494 | EStrcat (e1, e2) => wrap2 EStrcat (e1, e2)
ziv@2250 1495 (* We record page writes, so they're cachable. *)
ziv@2250 1496 | EWrite e => wrap1 EWrite e
ziv@2250 1497 | ESeq (e1, e2) => wrap2 ESeq (e1, e2)
ziv@2250 1498 | ELet (s, t, e1, e2) =>
ziv@2250 1499 wrapBind2 (fn (e1, e2) => ELet (s, t, e1, e2))
ziv@2271 1500 (((env, e1), Unknowns 0),
ziv@2271 1501 ((MonoEnv.pushERel env s t (SOME e1), e2), Known e1))
ziv@2250 1502 (* ASK: | EClosure (n, es) => ? *)
ziv@2250 1503 | EUnurlify (e, t, b) => wrap1 (fn e => EUnurlify (e, t, b)) e
ziv@2271 1504 | EQuery q => (cacheQuery (effs, env, q), state)
ziv@2269 1505 | _ => (if effectful effs env exp
ziv@2269 1506 then Impure exp
ziv@2271 1507 else Cachable (InvalInfo.empty,
ziv@2271 1508 fn state =>
ziv@2271 1509 case cacheExp (env, exp', InvalInfo.empty, state) of
ziv@2269 1510 NONE => ((exp', loc), state)
ziv@2269 1511 | SOME (exp', state) => ((exp', loc), state)),
ziv@2269 1512 state)
ziv@2256 1513 end
ziv@2256 1514
ziv@2266 1515 fun addCaching file =
ziv@2256 1516 let
ziv@2266 1517 val effs = effectfulDecls file
ziv@2271 1518 fun doTopLevelExp env exp state = runSubexp (cacheTree effs ((env, exp), state))
ziv@2256 1519 in
ziv@2271 1520 (fileTopLevelMapfoldB doTopLevelExp
ziv@2271 1521 file
ziv@2271 1522 {tableToIndices = SIMM.empty,
ziv@2271 1523 indexToInvalInfo = IM.empty,
ziv@2271 1524 ffiInfo = [],
ziv@2271 1525 index = 0},
ziv@2271 1526 effs)
ziv@2265 1527 end
ziv@2265 1528
ziv@2265 1529
ziv@2265 1530 (************)
ziv@2265 1531 (* Flushing *)
ziv@2265 1532 (************)
ziv@2265 1533
ziv@2265 1534 structure Invalidations = struct
ziv@2265 1535
ziv@2265 1536 val loc = dummyLoc
ziv@2265 1537
ziv@2265 1538 val optionAtomExpToExp =
ziv@2265 1539 fn NONE => (ENone stringTyp, loc)
ziv@2265 1540 | SOME e => (ESome (stringTyp,
ziv@2265 1541 (case e of
ziv@2265 1542 DmlRel n => ERel n
ziv@2265 1543 | Prim p => EPrim p
ziv@2265 1544 (* TODO: make new type containing only these two. *)
ziv@2294 1545 | _ => raise Fail "Sqlcache: Invalidations.optionAtomExpToExp",
ziv@2265 1546 loc)),
ziv@2265 1547 loc)
ziv@2265 1548
ziv@2265 1549 fun eqsToInvalidation numArgs eqs =
ziv@2269 1550 List.tabulate (numArgs, (fn n => IM.find (eqs, n)))
ziv@2265 1551
ziv@2265 1552 (* Tests if [ys] makes [xs] a redundant cache invalidation. [NONE] here
ziv@2265 1553 represents unknown, which means a wider invalidation. *)
ziv@2265 1554 val rec madeRedundantBy : atomExp option list * atomExp option list -> bool =
ziv@2265 1555 fn ([], []) => true
ziv@2265 1556 | (_ :: xs, NONE :: ys) => madeRedundantBy (xs, ys)
ziv@2265 1557 | (SOME x :: xs, SOME y :: ys) => (case AtomExpKey.compare (x, y) of
ziv@2265 1558 EQUAL => madeRedundantBy (xs, ys)
ziv@2265 1559 | _ => false)
ziv@2265 1560 | _ => false
ziv@2265 1561
ziv@2271 1562 fun invalidations ((invalInfo, numArgs), dml) =
ziv@2271 1563 let
ziv@2271 1564 val query = InvalInfo.query invalInfo
ziv@2271 1565 in
ziv@2271 1566 (map (map optionAtomExpToExp)
ziv@2271 1567 o removeRedundant madeRedundantBy
ziv@2271 1568 o map (eqsToInvalidation numArgs)
ziv@2273 1569 o conflictMaps)
ziv@2274 1570 (pairToFormulas (query, dml))
ziv@2271 1571 end
ziv@2265 1572
ziv@2265 1573 end
ziv@2265 1574
ziv@2265 1575 val invalidations = Invalidations.invalidations
ziv@2265 1576
ziv@2273 1577 fun addFlushing ((file, {tableToIndices, indexToInvalInfo, ffiInfo, ...} : state), effs) =
ziv@2265 1578 let
ziv@2265 1579 val flushes = List.concat
ziv@2265 1580 o map (fn (i, argss) => map (fn args => flush (i, args)) argss)
ziv@2265 1581 val doExp =
ziv@2267 1582 fn dmlExp as EDml (dmlText, failureMode) =>
ziv@2265 1583 let
ziv@2265 1584 val inval =
ziv@2265 1585 case Sql.parse Sql.dml dmlText of
ziv@2265 1586 SOME dmlParsed =>
ziv@2271 1587 SOME (map (fn i => (case IM.find (indexToInvalInfo, i) of
ziv@2271 1588 SOME invalInfo =>
ziv@2271 1589 (i, invalidations (invalInfo, dmlParsed))
ziv@2265 1590 (* TODO: fail more gracefully. *)
ziv@2271 1591 (* This probably means invalidating everything.... *)
ziv@2289 1592 | NONE => raise Fail "Sqlcache: addFlushing (a)"))
ziv@2271 1593 (SIMM.findList (tableToIndices, tableOfDml dmlParsed)))
ziv@2265 1594 | NONE => NONE
ziv@2265 1595 in
ziv@2265 1596 case inval of
ziv@2265 1597 (* TODO: fail more gracefully. *)
ziv@2289 1598 NONE => raise Fail "Sqlcache: addFlushing (b)"
ziv@2267 1599 | SOME invs => sequence (flushes invs @ [dmlExp])
ziv@2265 1600 end
ziv@2265 1601 | e' => e'
ziv@2274 1602 val file = fileMap doExp file
ziv@2274 1603
ziv@2265 1604 in
ziv@2268 1605 ffiInfoRef := ffiInfo;
ziv@2274 1606 file
ziv@2265 1607 end
ziv@2265 1608
ziv@2265 1609
ziv@2286 1610 (***********)
ziv@2286 1611 (* Locking *)
ziv@2286 1612 (***********)
ziv@2286 1613
ziv@2288 1614 (* TODO: do this less evilly by not relying on specific FFI names, please? *)
ziv@2289 1615 fun locksNeeded (lockMap : {store : IIMM.multimap, flush : IIMM.multimap}) =
ziv@2289 1616 MonoUtil.Exp.fold
ziv@2289 1617 {typ = #2,
ziv@2289 1618 exp = fn (EFfiApp ("Sqlcache", x, _), state as {store, flush}) =>
ziv@2289 1619 (case Int.fromString (String.extract (x, 5, NONE)) of
ziv@2289 1620 NONE => state
ziv@2289 1621 | SOME index =>
ziv@2289 1622 if String.isPrefix "flush" x
ziv@2289 1623 then {store = store, flush = IS.add (flush, index)}
ziv@2289 1624 else if String.isPrefix "store" x
ziv@2289 1625 then {store = IS.add (store, index), flush = flush}
ziv@2289 1626 else state)
ziv@2289 1627 | (ENamed n, {store, flush}) =>
ziv@2289 1628 {store = IS.union (store, IIMM.findSet (#store lockMap, n)),
ziv@2289 1629 flush = IS.union (flush, IIMM.findSet (#flush lockMap, n))}
ziv@2289 1630 | (_, state) => state}
ziv@2289 1631 {store = IS.empty, flush = IS.empty}
ziv@2289 1632
ziv@2289 1633 fun lockMapOfFile file =
ziv@2286 1634 transitiveAnalysis
ziv@2286 1635 (fn ((_, name, _, e, _), state) =>
ziv@2289 1636 let
ziv@2289 1637 val locks = locksNeeded state e
ziv@2289 1638 in
ziv@2289 1639 {store = IIMM.insertSet (#store state, name, #store locks),
ziv@2289 1640 flush = IIMM.insertSet (#flush state, name, #flush locks)}
ziv@2289 1641 end)
ziv@2286 1642 {store = IIMM.empty, flush = IIMM.empty}
ziv@2286 1643 file
ziv@2286 1644
ziv@2286 1645 fun exports (decls, _) =
ziv@2286 1646 List.foldl (fn ((DExport (_, _, n, _, _, _), _), ns) => IS.add (ns, n)
ziv@2286 1647 | (_, ns) => ns)
ziv@2286 1648 IS.empty
ziv@2286 1649 decls
ziv@2286 1650
ziv@2288 1651 fun wrapLocks (locks, (exp', loc)) =
ziv@2288 1652 case exp' of
ziv@2288 1653 EAbs (s, t1, t2, exp) => (EAbs (s, t1, t2, wrapLocks (locks, exp)), loc)
ziv@2288 1654 | _ => (List.foldr (fn (l, e') => sequence [lock l, e']) exp' locks, loc)
ziv@2286 1655
ziv@2288 1656 fun addLocking file =
ziv@2288 1657 let
ziv@2289 1658 val lockMap = lockMapOfFile file
ziv@2289 1659 fun lockList {store, flush} =
ziv@2288 1660 let
ziv@2289 1661 val ls = map (fn i => (i, true)) (IS.listItems flush)
ziv@2289 1662 @ map (fn i => (i, false)) (IS.listItems (IS.difference (store, flush)))
ziv@2288 1663 in
ziv@2288 1664 ListMergeSort.sort (fn ((i, _), (j, _)) => i > j) ls
ziv@2288 1665 end
ziv@2289 1666 fun locksOfName n =
ziv@2294 1667 lockList {flush = IIMM.findSet (#flush lockMap, n),
ziv@2294 1668 store = IIMM.findSet (#store lockMap, n)}
ziv@2289 1669 val locksOfExp = lockList o locksNeeded lockMap
ziv@2288 1670 val expts = exports file
ziv@2288 1671 fun doVal (v as (x, n, t, exp, s)) =
ziv@2288 1672 if IS.member (expts, n)
ziv@2289 1673 then (x, n, t, wrapLocks ((locksOfName n), exp), s)
ziv@2288 1674 else v
ziv@2288 1675 val doDecl =
ziv@2288 1676 fn (DVal v, loc) => (DVal (doVal v), loc)
ziv@2288 1677 | (DValRec vs, loc) => (DValRec (map doVal vs), loc)
ziv@2289 1678 | (DTask (exp1, exp2), loc) => (DTask (exp1, wrapLocks (locksOfExp exp2, exp2)), loc)
ziv@2288 1679 | decl => decl
ziv@2288 1680 in
ziv@2288 1681 mapFst (map doDecl) file
ziv@2288 1682 end
ziv@2288 1683
ziv@2286 1684
ziv@2268 1685 (************************)
ziv@2268 1686 (* Compiler Entry Point *)
ziv@2268 1687 (************************)
ziv@2265 1688
ziv@2265 1689 val inlineSql =
ziv@2265 1690 let
ziv@2265 1691 val doExp =
ziv@2265 1692 (* TODO: EQuery, too? *)
ziv@2265 1693 (* ASK: should this live in [MonoOpt]? *)
ziv@2265 1694 fn EDml ((ECase (disc, cases, {disc = dTyp, ...}), loc), failureMode) =>
ziv@2265 1695 let
ziv@2265 1696 val newCases = map (fn (p, e) => (p, (EDml (e, failureMode), loc))) cases
ziv@2265 1697 in
ziv@2265 1698 ECase (disc, newCases, {disc = dTyp, result = (TRecord [], loc)})
ziv@2265 1699 end
ziv@2265 1700 | e => e
ziv@2265 1701 in
ziv@2265 1702 fileMap doExp
ziv@2265 1703 end
ziv@2265 1704
ziv@2262 1705 fun insertAfterDatatypes ((decls, sideInfo), newDecls) =
ziv@2262 1706 let
ziv@2262 1707 val (datatypes, others) = List.partition (fn (DDatatype _, _) => true | _ => false) decls
ziv@2262 1708 in
ziv@2262 1709 (datatypes @ newDecls @ others, sideInfo)
ziv@2262 1710 end
ziv@2262 1711
ziv@2288 1712 val go' = addLocking o addFlushing o addCaching o simplifySql o inlineSql
ziv@2256 1713
ziv@2256 1714 fun go file =
ziv@2256 1715 let
ziv@2256 1716 (* TODO: do something nicer than [Sql] being in one of two modes. *)
ziv@2299 1717 val () = (resetFfiInfo ();
ziv@2299 1718 Sql.sqlcacheMode := true;
ziv@2299 1719 setHeuristic (Settings.getSqlcacheHeuristic ()))
ziv@2262 1720 val file = go' file
ziv@2262 1721 (* Important that this happens after [MonoFooify.urlify] calls! *)
ziv@2262 1722 val fmDecls = MonoFooify.getNewFmDecls ()
ziv@2256 1723 val () = Sql.sqlcacheMode := false
ziv@2256 1724 in
ziv@2262 1725 insertAfterDatatypes (file, rev fmDecls)
ziv@2250 1726 end
ziv@2250 1727
ziv@2209 1728 end