From d8981eb386223ce517647a497eee61759711fa19 Mon Sep 17 00:00:00 2001
From: keleher <keleher@cs.umd.edu>
Date: Wed, 27 Sep 2017 10:45:34 -0400
Subject: [PATCH] auto
---
.cshrc | 2 +-
...tional-Database-Design-Normalization.ipynb | 605 +++++++++++-------
2 files changed, 366 insertions(+), 241 deletions(-)
diff --git a/.cshrc b/.cshrc
index 06f1933..139f52c 100644
--- a/.cshrc
+++ b/.cshrc
@@ -17,7 +17,7 @@ a l ls -CF
a ll "ls -alh \!*"
a llm "ls -alh \!* | m"
a m 'less -i -M -e -c'
-a jup 'jupyter notebook --port=8889 --no-browser --ip=0.0.0.0'
+a jup 'jupyter notebook --port=8881 --no-browser --ip=0.0.0.0'
bindkey "^[h" backward-delete-word
bindkey "^[H" backward-delete-word
diff --git a/jupyter/07-Relational-Database-Design-Normalization.ipynb b/jupyter/07-Relational-Database-Design-Normalization.ipynb
index f455556..02b5eab 100644
--- a/jupyter/07-Relational-Database-Design-Normalization.ipynb
+++ b/jupyter/07-Relational-Database-Design-Normalization.ipynb
@@ -19,9 +19,7 @@
{
"cell_type": "code",
"execution_count": 1,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"from itertools import chain, combinations\n",
@@ -45,9 +43,7 @@
{
"cell_type": "code",
"execution_count": 2,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"# The following is not really needed for normalization, but may be useful to get intuitions about FDs\n",
@@ -61,7 +57,7 @@
" if len(t) == len(self.schema):\n",
" self.tuples.append(t)\n",
" else:\n",
- " print \"Added tuple does not match the length of the schema\"\n",
+ " print (\"Added tuple does not match the length of the schema\")\n",
" def checkIfMatch(self, t1, t2, attr_set):\n",
" return all(t1[self.schema.index(attr)] == t2[self.schema.index(attr)] for attr in attr_set)\n",
" def checkFDHolds(self, fd):\n",
@@ -70,9 +66,9 @@
" for t1 in self.tuples:\n",
" for t2 in self.tuples:\n",
" if t1 < t2 and self.checkIfMatch(t1, t2, fd.lhs) and not self.checkIfMatch(t1, t2, fd.rhs):\n",
- " print \"Tuples \" + str(t1) + \" and \" + str(t2) + \" violate the FD \" + str(fd)\n",
+ " print (\"Tuples \" + str(t1) + \" and \" + str(t2) + \" violate the FD \" + str(fd))\n",
" holds = False\n",
- " if holds: print \"FD \" + str(fd) + \" holds on this relation\""
+ " if holds: print (\"FD \" + str(fd) + \" holds on this relation\")"
]
},
{
@@ -88,9 +84,7 @@
{
"cell_type": "code",
"execution_count": 3,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [
{
"name": "stdout",
@@ -122,9 +116,7 @@
{
"cell_type": "code",
"execution_count": 4,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"# We need to construct powersets quite frequently.\n",
@@ -143,9 +135,7 @@
{
"cell_type": "code",
"execution_count": 5,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"def applyreflexivity(R):\n",
@@ -164,9 +154,7 @@
{
"cell_type": "code",
"execution_count": 6,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"def applyaugmentation(F, PW, printflag):\n",
@@ -175,7 +163,7 @@
" \"\"\"\n",
" N = {FD(x.lhs.union(y), x.rhs.union(y)) for x in F for y in PW}\n",
" for fd in N - F:\n",
- " if printflag: print \" Adding \" + str(fd) + \" by Augmenting \" + str(x) + \" using \" + \"\".join(y)\n",
+ " if printflag: print (\" Adding \" + str(fd) + \" by Augmenting \" + str(x) + \" using \" + \"\".join(y))\n",
" return F.union(N)"
]
},
@@ -189,9 +177,7 @@
{
"cell_type": "code",
"execution_count": 7,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"def applytransitivity(F, printflag):\n",
@@ -199,7 +185,7 @@
" N = { FD(x.lhs, y.rhs) for x in F for y in F if x.rhs == y.lhs }\n",
" for fd in N - F:\n",
" if printflag:\n",
- " print \" Adding \" + str(fd) + \" using Transitivity from \" + str(x) + \" and \" + str(y)\n",
+ " print (\" Adding \" + str(fd) + \" using Transitivity from \" + str(x) + \" and \" + str(y))\n",
" return F.union(N)"
]
},
@@ -213,9 +199,7 @@
{
"cell_type": "code",
"execution_count": 8,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"def findClosure(R, F, printflag = False):\n",
@@ -228,13 +212,13 @@
" # Repeat application of the other two rules until no change\n",
" done = False;\n",
" while done == False:\n",
- " if printflag: print \"Trying to find new FDs using Transitivity\"\n",
+ " if printflag: print (\"Trying to find new FDs using Transitivity\")\n",
" F2 = applytransitivity(F, printflag)\n",
- " if printflag: print \"Trying to find new FDs using Augmentation\"\n",
+ " if printflag: print (\"Trying to find new FDs using Augmentation\")\n",
" F2 = applyaugmentation(F2, powerset(R), printflag)\n",
" done = len(F2) == len(F)\n",
" F = F2\n",
- " if printflag: print \"Finished\"\n",
+ " if printflag: print (\"Finished\")\n",
" return F"
]
},
@@ -248,9 +232,7 @@
{
"cell_type": "code",
"execution_count": 9,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"def findKeys(R, FClosure):\n",
@@ -281,10 +263,8 @@
},
{
"cell_type": "code",
- "execution_count": 33,
- "metadata": {
- "collapsed": false
- },
+ "execution_count": 10,
+ "metadata": {},
"outputs": [],
"source": [
"def isInBCNF(R, FClosure, keys):\n",
@@ -299,7 +279,7 @@
" \"\"\"Same as above, but finds all violations and prints them\"\"\"\n",
" for fd in FClosure:\n",
" if (not fd.isTrivial()) and (fd.lhs not in keys):\n",
- " print str(fd) + \" is an FD whose LHS is not a key\"\n",
+ " print (str(fd) + \" is an FD whose LHS is not a key\")\n",
"\n",
"def findSmallestViolatingFD(R, FClosure, keys):\n",
" \"\"\"Same as above, but finds a small FD that violates\"\"\"\n",
@@ -319,9 +299,7 @@
{
"cell_type": "code",
"execution_count": 11,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [],
"source": [
"def DecomposeUsingFD(R, FClosure, fd):\n",
@@ -342,18 +320,18 @@
"def BCNFDecomposition(R, FClosure):\n",
" keys = findKeys(R, FClosure)\n",
" if not isInBCNF(R, FClosure, keys):\n",
- " print \"\".join(R) + \" is not in BCNF\"\n",
+ " print (\"\".join(R) + \" is not in BCNF\")\n",
" fd = findSmallestViolatingFD(R, FClosure, keys)\n",
"\n",
" # Decompose using that FD\n",
" (R1, R2, F1Closure, F2Closure) = DecomposeUsingFD(R, FClosure, fd)\n",
- " print \"Decomposing \" + \"\".join(R) + \" using \" + str(fd) + \" into relations \" + \"\".join(R1) + \" and \" + \"\".join(R2)\n",
+ " print (\"Decomposing \" + \"\".join(R) + \" using \" + str(fd) + \" into relations \" + \"\".join(R1) + \" and \" + \"\".join(R2))\n",
"\n",
" # Recurse\n",
" BCNFDecomposition(R1, F1Closure)\n",
" BCNFDecomposition(R2, F2Closure)\n",
" else:\n",
- " print \"\".join(R) + \" is in BCNF\""
+ " print (\"\".join(R) + \" is in BCNF\")"
]
},
{
@@ -366,10 +344,8 @@
},
{
"cell_type": "code",
- "execution_count": 12,
- "metadata": {
- "collapsed": false
- },
+ "execution_count": 18,
+ "metadata": {},
"outputs": [],
"source": [
"R = \"ABCD\"\n",
@@ -379,110 +355,108 @@
{
"cell_type": "code",
"execution_count": 13,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "CB -> AC\n",
- "ACD -> B\n",
- "BD -> AD\n",
- "D -> A\n",
- "AC -> ACD\n",
- "ACD -> ABD\n",
- "ACD -> CBD\n",
- "CD -> BD\n",
- "A -> AB\n",
- "ACB -> AD\n",
- "CBD -> AC\n",
- "AC -> CB\n",
- "BD -> A\n",
- "ACB -> D\n",
- "CD -> AB\n",
- "CB -> AB\n",
- "AC -> AD\n",
- "AD -> ABD\n",
- "CB -> BD\n",
- "A -> B\n",
- "AD -> BD\n",
- "CD -> AC\n",
- "CD -> CBD\n",
- "CB -> AD\n",
- "CB -> CD\n",
- "AC -> ACB\n",
- "CBD -> A\n",
- "BD -> ABD\n",
- "D -> BD\n",
- "CBD -> AD\n",
+ "D -> DB\n",
+ "DCA -> DBA\n",
+ "CA -> BCA\n",
"CB -> A\n",
- "AC -> BD\n",
- "CB -> ABD\n",
- "ACB -> ACD\n",
- "ACB -> CBD\n",
- "CD -> ACD\n",
- "ACB -> ABD\n",
- "CD -> ABD\n",
- "CB -> ACB\n",
"D -> B\n",
- "AC -> CD\n",
- "BD -> AB\n",
+ "DCA -> BCA\n",
+ "BCA -> DCA\n",
+ "BCA -> DB\n",
+ "CB -> DBA\n",
+ "DC -> DBCA\n",
+ "ACB -> D\n",
+ "D -> DA\n",
+ "DA -> B\n",
+ "DCB -> DCA\n",
+ "DCA -> DCB\n",
+ "DB -> A\n",
+ "DCB -> DAB\n",
+ "DC -> A\n",
+ "DC -> DB\n",
+ "DC -> AB\n",
+ "DCB -> DA\n",
+ "CB -> DB\n",
+ "BCA -> DAB\n",
+ "DCA -> BA\n",
+ "DA -> BA\n",
+ "CB -> ACB\n",
+ "CB -> CA\n",
+ "CA -> CB\n",
+ "DC -> DCB\n",
+ "CA -> BA\n",
+ "DA -> DBA\n",
+ "BCA -> DA\n",
+ "D -> DBA\n",
+ "CA -> B\n",
"CB -> D\n",
- "ACD -> BD\n",
- "AC -> AB\n",
- "AC -> B\n",
- "ACD -> ACB\n",
- "D -> AB\n",
- "ACB -> BD\n",
- "CD -> AD\n",
- "CD -> ACB\n",
- "CD -> A\n",
- "CB -> ACBD\n",
- "ACB -> ACBD\n",
- "CB -> CBD\n",
- "CD -> B\n",
- "ACD -> AB\n",
- "CBD -> ABD\n",
- "CBD -> ACB\n",
- "AD -> B\n",
- "AD -> AB\n",
- "CBD -> AB\n",
- "CBD -> ACD\n",
- "CBD -> ACBD\n",
- "ACD -> CB\n",
- "AC -> ACBD\n",
- "AC -> CBD\n",
- "CB -> ACD\n",
- "ACD -> ACBD\n",
- "CD -> ACBD\n",
- "AC -> D\n",
- "D -> AD\n",
- "CD -> CB\n",
- "ACB -> CD\n",
- "AC -> ABD\n",
- "D -> ABD\n",
+ "DCB -> ACB\n",
+ "BCA -> DCB\n",
+ "CB -> DA\n",
+ "DC -> B\n",
+ "DCB -> A\n",
+ "DC -> DA\n",
+ "BCA -> DC\n",
+ "DC -> BCA\n",
+ "DB -> AB\n",
+ "DB -> DAB\n",
+ "CB -> DCB\n",
+ "CA -> DB\n",
+ "CA -> DCA\n",
+ "DCA -> DB\n",
+ "D -> A\n",
+ "CA -> D\n",
+ "DCA -> CB\n",
+ "CB -> DCA\n",
+ "DA -> DB\n",
+ "DC -> DCA\n",
+ "DB -> DA\n",
+ "A -> B\n",
+ "DCA -> DBCA\n",
+ "CA -> DBA\n",
+ "DCB -> DACB\n",
+ "D -> BA\n",
+ "BCA -> DACB\n",
+ "CA -> DBCA\n",
+ "CB -> AB\n",
+ "A -> BA\n",
+ "DC -> CB\n",
+ "CB -> DC\n",
+ "CB -> DBCA\n",
+ "CA -> DA\n",
+ "DCB -> CA\n",
+ "CA -> DCB\n",
+ "DCA -> B\n",
+ "DC -> CA\n",
+ "DCB -> AB\n",
+ "CA -> DC\n",
+ "DC -> DBA\n",
"Keys are:\n",
- "ACB\n",
- "CBD\n",
- "ACD\n",
- "ACBD\n",
+ "BCA\n",
+ "CA\n",
+ "DBCA\n",
+ "DCB\n",
"CB\n",
- "AC\n",
- "CD\n"
+ "DCA\n",
+ "DC\n"
]
}
],
"source": [
"Fclosure = findClosure(R, F)\n",
"for i in Fclosure:\n",
- " if not i.isTrivial(): print i\n",
+ " if not i.isTrivial(): print (i)\n",
"\n",
"keys = findKeys(R, Fclosure)\n",
- "print \"Keys are:\"\n",
+ "print (\"Keys are:\")\n",
"for i in keys:\n",
- " print \"\".join(i)"
+ " print (\"\".join(i))"
]
},
{
@@ -495,48 +469,37 @@
{
"cell_type": "code",
"execution_count": 14,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [
{
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Candidate Keys are:\n",
- "CB\n",
- "AC\n",
- "CD\n"
+ "ename": "TypeError",
+ "evalue": "must use keyword argument for key function",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m<ipython-input-14-f976dc9cf4d4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcandidatekeys\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfindCandidateKeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mR\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mFclosure\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"Candidate Keys are:\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mcandidatekeys\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m<ipython-input-9-3a26a87149f6>\u001b[0m in \u001b[0;36mfindCandidateKeys\u001b[0;34m(R, FClosure)\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0mkeys\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfindKeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mR\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mFClosure\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mckeys\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msorted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mcmp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0mdontadd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mck\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mckeys\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mTypeError\u001b[0m: must use keyword argument for key function"
]
}
],
"source": [
"candidatekeys = findCandidateKeys(R, Fclosure)\n",
- "print \"Candidate Keys are:\"\n",
+ "print (\"Candidate Keys are:\")\n",
"for i in candidatekeys:\n",
- " print \"\".join(i)"
+ " print (\"\".join(i))"
]
},
{
"cell_type": "code",
- "execution_count": 20,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Checking if the schema is in BCNF\n",
- "Decomposing using B -> C into relations CB and ABD\n"
- ]
- }
- ],
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
"source": [
- "print \"Checking if the schema is in BCNF\"\n",
+ "print (\"Checking if the schema is in BCNF\")\n",
"if isInBCNF(R, Fclosure, keys):\n",
- " print \"The schema is in BCNF\"\n",
+ " print (\"The schema is in BCNF\")\n",
"\n",
"(R1, R2, F1Closure, F2Closure) = DecomposeUsingFD(R, Fclosure, FD('B', 'C'))\n",
"print \"Decomposing using \" + str(FD('B', 'C')) + \" into relations \" + \"\".join(R1) + \" and \" + \"\".join(R2)"
@@ -544,31 +507,13 @@
},
{
"cell_type": "code",
- "execution_count": 21,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "-------------- Doing a full BCNF Decompisition -------\n",
- "ABCD is not in BCNF\n",
- "Decomposing ABCD using D -> A into relations AD and CBD\n",
- "AD is in BCNF\n",
- "CBD is not in BCNF\n",
- "Decomposing CBD using D -> B into relations BD and CD\n",
- "BD is in BCNF\n",
- "CD is in BCNF\n",
- "------------------------------------------------------\n"
- ]
- }
- ],
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
"source": [
- "print \"-------------- Doing a full BCNF Decompisition -------\"\n",
+ "print (\"-------------- Doing a full BCNF Decompisition -------\")\n",
"BCNFDecomposition(R, Fclosure)\n",
- "print \"------------------------------------------------------\""
+ "print (\"------------------------------------------------------\")"
]
},
{
@@ -581,52 +526,25 @@
},
{
"cell_type": "code",
- "execution_count": 35,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Candidate Keys are:\n",
- "ED\n",
- "Checking if the schema is in BCNF\n",
- "-------------- NO: Doing a full BCNF Decompisition -------\n",
- "ABCDEH is not in BCNF\n",
- "Decomposing ABCDEH using E -> B into relations BE and AHCED\n",
- "BE is in BCNF\n",
- "AHCED is not in BCNF\n",
- "Decomposing AHCED using E -> C into relations CE and AHED\n",
- "CE is in BCNF\n",
- "AHED is not in BCNF\n",
- "Decomposing AHED using E -> H into relations HE and AED\n",
- "HE is in BCNF\n",
- "AED is not in BCNF\n",
- "Decomposing AED using E -> A into relations AE and ED\n",
- "AE is in BCNF\n",
- "ED is in BCNF\n",
- "------------------------------------------------------\n"
- ]
- }
- ],
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
"source": [
"R2 = \"ABCDEH\"\n",
"F2 = {FD('A', 'BC'), FD('E', 'HA')}\n",
"Fclosure2 = findClosure(R2, F2)\n",
"keys = findKeys(R2, Fclosure2)\n",
"candidatekeys = findCandidateKeys(R2, Fclosure2)\n",
- "print \"Candidate Keys are:\"\n",
+ "print (\"Candidate Keys are:\")\n",
"for i in candidatekeys:\n",
- " print \"\".join(i)\n",
- "print \"Checking if the schema is in BCNF\"\n",
+ " print (\"\".join(i))\n",
+ "print (\"Checking if the schema is in BCNF\")\n",
"if isInBCNF(R2, Fclosure2, keys):\n",
- " print \"The schema is in BCNF\"\n",
+ " print (\"The schema is in BCNF\")\n",
"else:\n",
- " print \"-------------- NO: Doing a full BCNF Decompisition -------\"\n",
+ " print (\"-------------- NO: Doing a full BCNF Decompisition -------\")\n",
" BCNFDecomposition(R2, Fclosure2)\n",
- " print \"------------------------------------------------------\""
+ " print (\"------------------------------------------------------\")"
]
},
{
@@ -637,33 +555,240 @@
"Below is the smallest relation schema and FDs such that, there is no dependency-preserving BCNF decomposition. In this case, the schema is not in BCNF and needs to be split; but if we do that, then we cannot check for the FD JK --> L without doing a join. The original schema (\"JKL\") is in 3NF"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "BCNFDecomposition(\"JKL\", findClosure(\"JKL\", {FD('JK', 'L'), FD('L', 'K')}))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{<__main__.FD at 0x7f765c969588>,\n",
+ " <__main__.FD at 0x7f765c969d30>,\n",
+ " <__main__.FD at 0x7f765c969390>,\n",
+ " <__main__.FD at 0x7f765d1c5898>,\n",
+ " <__main__.FD at 0x7f765c964198>,\n",
+ " <__main__.FD at 0x7f765c9695f8>,\n",
+ " <__main__.FD at 0x7f765c969470>,\n",
+ " <__main__.FD at 0x7f765c964e10>,\n",
+ " <__main__.FD at 0x7f765c9647f0>,\n",
+ " <__main__.FD at 0x7f7660ab2b38>,\n",
+ " <__main__.FD at 0x7f765c9691d0>,\n",
+ " <__main__.FD at 0x7f765d1c5ef0>,\n",
+ " <__main__.FD at 0x7f765c969898>,\n",
+ " <__main__.FD at 0x7f765c964470>,\n",
+ " <__main__.FD at 0x7f765c964748>,\n",
+ " <__main__.FD at 0x7f7660a59f60>,\n",
+ " <__main__.FD at 0x7f765c969b70>,\n",
+ " <__main__.FD at 0x7f765c9852b0>,\n",
+ " <__main__.FD at 0x7f765c9692e8>,\n",
+ " <__main__.FD at 0x7f765d1c5400>,\n",
+ " <__main__.FD at 0x7f765c969128>,\n",
+ " <__main__.FD at 0x7f7660ab2f98>,\n",
+ " <__main__.FD at 0x7f765c969710>,\n",
+ " <__main__.FD at 0x7f765c969630>,\n",
+ " <__main__.FD at 0x7f765c969208>,\n",
+ " <__main__.FD at 0x7f765c964400>,\n",
+ " <__main__.FD at 0x7f765d1c5748>,\n",
+ " <__main__.FD at 0x7f765c9644e0>,\n",
+ " <__main__.FD at 0x7f765c969438>,\n",
+ " <__main__.FD at 0x7f765c9690b8>,\n",
+ " <__main__.FD at 0x7f765c969278>,\n",
+ " <__main__.FD at 0x7f7660ab2a90>,\n",
+ " <__main__.FD at 0x7f765d1c5550>,\n",
+ " <__main__.FD at 0x7f7660ab26d8>,\n",
+ " <__main__.FD at 0x7f765c964f28>,\n",
+ " <__main__.FD at 0x7f7660a59860>,\n",
+ " <__main__.FD at 0x7f765d1c56a0>,\n",
+ " <__main__.FD at 0x7f765c9641d0>,\n",
+ " <__main__.FD at 0x7f765c964828>,\n",
+ " <__main__.FD at 0x7f765c964048>,\n",
+ " <__main__.FD at 0x7f765d1c58d0>,\n",
+ " <__main__.FD at 0x7f765c969940>,\n",
+ " <__main__.FD at 0x7f765d1c5be0>,\n",
+ " <__main__.FD at 0x7f765d1c5940>,\n",
+ " <__main__.FD at 0x7f765c9645c0>,\n",
+ " <__main__.FD at 0x7f765c9696d8>,\n",
+ " <__main__.FD at 0x7f765d1c5dd8>,\n",
+ " <__main__.FD at 0x7f765c9640f0>,\n",
+ " <__main__.FD at 0x7f765c9694e0>,\n",
+ " <__main__.FD at 0x7f765c9692b0>,\n",
+ " <__main__.FD at 0x7f765d1c5e80>,\n",
+ " <__main__.FD at 0x7f765c969e10>,\n",
+ " <__main__.FD at 0x7f765c969080>,\n",
+ " <__main__.FD at 0x7f765c9697b8>,\n",
+ " <__main__.FD at 0x7f765c969f98>,\n",
+ " <__main__.FD at 0x7f765c9694a8>,\n",
+ " <__main__.FD at 0x7f7660ab2f60>,\n",
+ " <__main__.FD at 0x7f765c964da0>,\n",
+ " <__main__.FD at 0x7f765c94de80>,\n",
+ " <__main__.FD at 0x7f7660ab2c50>,\n",
+ " <__main__.FD at 0x7f765c964550>,\n",
+ " <__main__.FD at 0x7f765c969c88>,\n",
+ " <__main__.FD at 0x7f7660a59e80>,\n",
+ " <__main__.FD at 0x7f765c969550>,\n",
+ " <__main__.FD at 0x7f765c969a20>,\n",
+ " <__main__.FD at 0x7f765c964940>,\n",
+ " <__main__.FD at 0x7f765c969908>,\n",
+ " <__main__.FD at 0x7f765d1c52b0>,\n",
+ " <__main__.FD at 0x7f765c964ef0>,\n",
+ " <__main__.FD at 0x7f765c9644a8>,\n",
+ " <__main__.FD at 0x7f765c985278>,\n",
+ " <__main__.FD at 0x7f765c969cf8>,\n",
+ " <__main__.FD at 0x7f765c969320>,\n",
+ " <__main__.FD at 0x7f765c969668>,\n",
+ " <__main__.FD at 0x7f765c969cc0>,\n",
+ " <__main__.FD at 0x7f7660ab29b0>,\n",
+ " <__main__.FD at 0x7f7660ab27b8>,\n",
+ " <__main__.FD at 0x7f765c969828>,\n",
+ " <__main__.FD at 0x7f765c9696a0>,\n",
+ " <__main__.FD at 0x7f765c969240>,\n",
+ " <__main__.FD at 0x7f765c9695c0>,\n",
+ " <__main__.FD at 0x7f765c964278>,\n",
+ " <__main__.FD at 0x7f765d1c5240>,\n",
+ " <__main__.FD at 0x7f765c9697f0>,\n",
+ " <__main__.FD at 0x7f765d1c5f28>,\n",
+ " <__main__.FD at 0x7f765c9640b8>,\n",
+ " <__main__.FD at 0x7f765c94d4a8>,\n",
+ " <__main__.FD at 0x7f765d1c5860>,\n",
+ " <__main__.FD at 0x7f765c969c18>,\n",
+ " <__main__.FD at 0x7f765c969358>,\n",
+ " <__main__.FD at 0x7f765c969978>,\n",
+ " <__main__.FD at 0x7f765c964668>,\n",
+ " <__main__.FD at 0x7f765c985160>,\n",
+ " <__main__.FD at 0x7f765c9693c8>,\n",
+ " <__main__.FD at 0x7f765c969a58>,\n",
+ " <__main__.FD at 0x7f765c969780>,\n",
+ " <__main__.FD at 0x7f765c964f98>,\n",
+ " <__main__.FD at 0x7f765c969748>,\n",
+ " <__main__.FD at 0x7f7660ab2828>,\n",
+ " <__main__.FD at 0x7f765c964e48>,\n",
+ " <__main__.FD at 0x7f765c94d160>,\n",
+ " <__main__.FD at 0x7f765c9698d0>,\n",
+ " <__main__.FD at 0x7f765c969ba8>,\n",
+ " <__main__.FD at 0x7f7660ab2fd0>,\n",
+ " <__main__.FD at 0x7f765c969d68>,\n",
+ " <__main__.FD at 0x7f765d1c5438>,\n",
+ " <__main__.FD at 0x7f765c969160>,\n",
+ " <__main__.FD at 0x7f7660ab2c18>,\n",
+ " <__main__.FD at 0x7f765d1c5518>,\n",
+ " <__main__.FD at 0x7f7660ab28d0>,\n",
+ " <__main__.FD at 0x7f7660ab2e80>,\n",
+ " <__main__.FD at 0x7f765c964898>,\n",
+ " <__main__.FD at 0x7f765c969ac8>,\n",
+ " <__main__.FD at 0x7f765c964fd0>,\n",
+ " <__main__.FD at 0x7f765d1c5c50>,\n",
+ " <__main__.FD at 0x7f765c969048>,\n",
+ " <__main__.FD at 0x7f765c969518>,\n",
+ " <__main__.FD at 0x7f765c969400>,\n",
+ " <__main__.FD at 0x7f765c969b00>,\n",
+ " <__main__.FD at 0x7f765c969dd8>,\n",
+ " <__main__.FD at 0x7f765c9649b0>,\n",
+ " <__main__.FD at 0x7f765c9699b0>,\n",
+ " <__main__.FD at 0x7f765d1c5cc0>,\n",
+ " <__main__.FD at 0x7f765c9642b0>,\n",
+ " <__main__.FD at 0x7f765c969860>,\n",
+ " <__main__.FD at 0x7f765c969198>,\n",
+ " <__main__.FD at 0x7f765c9690f0>,\n",
+ " <__main__.FD at 0x7f765c969a90>,\n",
+ " <__main__.FD at 0x7f765c985208>,\n",
+ " <__main__.FD at 0x7f765da3e0f0>,\n",
+ " <__main__.FD at 0x7f765c969da0>,\n",
+ " <__main__.FD at 0x7f765c964630>,\n",
+ " <__main__.FD at 0x7f765da3e160>,\n",
+ " <__main__.FD at 0x7f765c964588>,\n",
+ " <__main__.FD at 0x7f765c969b38>,\n",
+ " <__main__.FD at 0x7f7660ab26a0>,\n",
+ " <__main__.FD at 0x7f765c964eb8>,\n",
+ " <__main__.FD at 0x7f765c964dd8>,\n",
+ " <__main__.FD at 0x7f765c985240>,\n",
+ " <__main__.FD at 0x7f765c9699e8>,\n",
+ " <__main__.FD at 0x7f765c969be0>}"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Fclosure"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'ABCD'"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "R"
+ ]
+ },
{
"cell_type": "code",
"execution_count": 19,
- "metadata": {
- "collapsed": false
- },
+ "metadata": {},
"outputs": [
{
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "JKL is not in BCNF\n",
- "Decomposing JKL using L -> KL into relations KL and JL\n",
- "KL is in BCNF\n",
- "JL is in BCNF\n"
+ "data": {
+ "text/plain": [
+ "{<__main__.FD at 0x7f765d1c5390>,\n",
+ " <__main__.FD at 0x7f765d1c54e0>,\n",
+ " <__main__.FD at 0x7f765d1c5cf8>}"
+ ]
+ },
+ "execution_count": 19,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "F"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "unexpected EOF while parsing (<ipython-input-20-92c25cba582c>, line 1)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;36m File \u001b[0;32m\"<ipython-input-20-92c25cba582c>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m FD('A', 'B'\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m unexpected EOF while parsing\n"
]
}
],
"source": [
- "BCNFDecomposition(\"JKL\", findClosure(\"JKL\", {FD('JK', 'L'), FD('L', 'K')}))"
+ "FD('A', 'B'"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
- "collapsed": false
+ "collapsed": true
},
"outputs": [],
"source": []
@@ -671,23 +796,23 @@
],
"metadata": {
"kernelspec": {
- "display_name": "Python 2",
+ "display_name": "Python 3",
"language": "python",
- "name": "python2"
+ "name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
- "version": 2
+ "version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
- "pygments_lexer": "ipython2",
- "version": "2.7.6"
+ "pygments_lexer": "ipython3",
+ "version": "3.5.2"
}
},
"nbformat": 4,
- "nbformat_minor": 0
+ "nbformat_minor": 1
}
--
GitLab