My talk, "T

1. The Reemergence of Datalog

2. Return of the
Living
Datalog

3. I like
turtles

4. Data

5. Rectangles

6. RDL

8. Rectangulation
• Relationship between entities
• Sparse data
• Multi-valued attributes
• PLace-Oriented Programming

9. Java

10. Java

11. Where’s
the
Data?
Java

12. Java

13. Java

15. RDL

16. ORMG!

17. Code as Code.
Data as Data.

18. Code as Code.
Data as Data.

20. Cookies
User information
Protocols
Lisp
Schemas
Events
Chess moves
as Data.
TX
...

21. Code as Code.
Data as Data.

22. Unification

23. Your data

24. punching holes in
Your data

25. fitting the holes in
Your data

26. Variables

27. Deriving bindings

28. Substitution

29. Leaving variables

30. Related variables

31. MGU

32. Prolog

33. Prolog data

34. Prolog facts

35. Prolog rules

36. Prolog query

37. Data as Code!

38. Data as Code!
Caveat
Emptor

39. Caveats
• Clause-order dependence
• Non-termination
• Infection of imperative

40. Clause order dependence

41. Clause order dependence

42. Non-termination

43. Non-termination

44. Fixed?

45. Imperative infection
•!
• fail

46. Cut

47. Cut

48. fail

49. Prolog is prelude
• Powerful
• Often beautiful
• Not as declarative as we’d like

50. Datalog

51. Datalog is...
• A query language
• Not Turing complete
• Explicit
• Simple
• to use
• ... and implement
• ... kinda

52. History
• 1977: Gallaire and Minker's Symposium on
Logic Data Bases
• 1980s: Nail, LDL, Coral
• 1995: Stonebraker and Hellerstein declare
"no practical applications …"
• The dark years...

53. History
• 2002: Binder, a logic-based security language
by DeTreville
• 2000s: Declarative networking, bddbddb,
Orchestra CDSS, Doop, SecureBlox,
Dedalus, more
• 2010: The Declarative Imperative by
Hellerstein!
• Today: Bloom, Cascalog, Datomic,
LogicBlox, more

54. Datalog is also
• Declarative logic programming with
termination
• Recursive queries
• Implicit joins

55. EAV
• “Entities” (objects?) - a grouping of tuples
• Make that efficient

56. Query elements

57. Patterns

58. Simple query
• Find all language entities with a website entry

59. Simple query
• Find all language entities with a website entry
entity
attribute

60. Binding query
• Find all language URLs with a website entry
entity
attribute
value

61. Join
• Repeating ?language indicates a join

62. Rules
head
body
• All variables in the head, must appear in the
body

63. Recursive rules

64. Recursive rules
Simula LISP
Smalltalk
Dart

65. Datomic

66. Datalog plus
• No need for a database
• Time travel

67. Where’s the DB?

68. Where’s the DB?

69. Where’s the DB?

70. Where’s the DB?

71. now
• How do you keep
a notion of time in
a relational
database?
• Ever write now()?

72. Always?

73. Time
• Total ordering of transactions
• Every datom retains a reference to its
enclosing transaction
• Transactions are first-class entities, can have
their own attributes

74. Time
• You can obtain the value of the db as-of, or
since, a point in time, or both
• without parameterizing your logic with a
time argument
• You can also get the entire history of an
entity!

75. Datomic is also
• Fully navigable lazy entity maps
• Query across databases
• Optimistic and pessimistic concurrency
• “Upsertting”
• http://datomic.com

76. Dedalus

77. Datalog plus
• Time
• State via rules

78. Time
• Tick model
• Time is an element of the tuple

79. Deductive time
• “Right now”

80. Deductive time
• “Right now”
• All terms have the same time...

81. Inductive time
• “Some other time”

82. Inductive time
• “Some other time”
• Next time tick

83. Async time
• Unreliable network

84. State
• At time tick 0

85. State
• At time tick 0
• Facts

86. Update
• At time tick 100
• Facts

87. Update
• At time tick 300
• Facts

88. Mutable persistence rule

89. Mutable persistence rule
• Update

90. Cascalog

91. Datalog plus
• Map/reduce processing
• Order independence a win

92. Cascalog

93. Three stages
• Pre-aggregation
• Aggregation
• Post-aggregation
Pre- Post-
Aggregation
aggregation aggregation

94. Pre-aggregation
• Joins aggregator functions
• Applies bindable functions and filters
• Dataflow-esque
Pre- Post-
Aggregation
aggregation aggregation

95. Aggregation
• Partition result tuples along logic variables
• Execute aggregators for each logic var
Pre- Post-
Aggregation
aggregation aggregation

96. Post-aggregation
• Execute the the remaining filters and
functions on dependent aggregator output
Pre- Post-
Aggregation
aggregation aggregation

97. Example
Pre- Post-
Aggregation
aggregation aggregation

98. Pre-aggregation
Pre- Post-
Aggregation
aggregation aggregation

99. Aggregation
Pre- Post-
Aggregation
aggregation aggregation

100. Post-aggregation
Pre- Post-
Aggregation
aggregation aggregation

101. Bacwn

102. Datalog plus
• Negation

103. Delicious!

104. Bacwn facts

105. Bacwn rules!

106. Bacwn query

107. Bacwn negation

108. Bacwn negation
• Find all non-humans at a location

109. Open
questions
• Query plans
• Optimizations

110. Query plans
• The holy grail of DBs is that they do the
right thing
• Query plans
• No runtime guarantees

111. Gaming the query
• /*+ Hinting */
• Prolog - Ordering for termination
• Datalog - Ordering for speed

112. Gaming the query
• /*+ Hinting */
• Prolog - Ordering for termination
• Datalog - Ordering for speed

113. Wut
• Find all descendants of root number #100
with value = 4
• SLLLLLLOOOOOOWWWW

114. Wat
• Find all descendants of root number #100
with value = 4
• FAST!!

115. Wat
• Find all descendants of root number #100
with value = 4
• Most-bound

116. Order doesn’t
matter
Except when
it does

117. Pluggable Optimizers
• Order agnostic is a win
• Some orders are better than others
• Plug in your own optimizer
• That knows your data
• Will not affect other Datalog engine
optimization techniques

118. • Rich Hickey, Stu THX!
Halloway, Clojure/core
• Clojure/dev
• Manning Publications
• The fam
• You

119. double-secret slides

120. ?
(foo) engine

121. ?
(foo) engine

122. ?
(foo) engine

123. ?
(foo) engine

124. Data as Data.

125. Scalar

126. Scalar

127. Client ? Server

128. JSON
Client Server
JSON as Data

129. Client ? Server
Clojure as Code
118

130. Client Server
Clojure as Data
119

131. as Code.
Data

132. Engine
121

133. Specification Engine
122

134. Specification Engine
123

135. I’m really
doing
something
cool
Specification Engine now
124

136. Code
as Data.

137. Function call
semantics: fn call arg
(println "Hello World")
structure: symbol string
list
126

138. Function definition
define a fn fn name
docstring
(defn greet
"Returns a friendly greeting"
[your-name]
(str "Hello, " your-name))
arguments
fn body
127

139. It's all data
symbol symbol
string
(defn greet
"Returns a friendly greeting"
[your-name]
(str "Hello, " your-name))
vector
list
128