diff --git a/hw/hw1/hw1.md b/hw/hw1/hw1.md
deleted file mode 100644
index e14e4921de15dbaf29271440319a14cb2e92d9ba..0000000000000000000000000000000000000000
--- a/hw/hw1/hw1.md
+++ /dev/null
@@ -1,531 +0,0 @@
-# CSE 544 Homework 1: Data Analytics Pipeline
-
-**Objectives:** To get familiar with the main components of the data analytic pipeline: schema design, data acquisition, data transformation, querying, and visualizing.
-
-**Assignment tools:** postgres, excel (or some other tool for visualization)
-
-**Assigned date:** January 3rd, 2018
-
-**Due date:** January 19, 2018
-
-**Questions:** on the [google discussion board](https://groups.google.com/a/cs.washington.edu/forum/#!forum/cse544-18wi-discussion).
-
-**What to turn in:** These files: `pubER.pdf`, `createPubSchema.sql`, `importPubData.sql`, `solution.sql`, `graph.py`, `graph.pdf`. Your `solution.sql` file should be executable using the command `psql -f solution.sql`
-
-Turn in your solution on [CSE's GitLab](https://gitlab.cs.washington.edu).
-See [submission instructions](#submission) below.
-
-
-**Motivation:** In this homework you will implement a basic data
-analysis pipeline: data acquisition, transformation and extraction,
-cleaning, analysis and sharing of results. The data is
-[DBLP](http://www.informatik.uni-trier.de/~ley/db/), the reference
-citation website created and maintained by Michael Ley. The analysis
-will be done in postgres. The visualization in excel, or any other
-tool of your choice.
-
-
-**Resources:**
-
-- [postgres](https://www.postgresql.org/)
-
-- starter code
-
-
-
-# Problems
-
-## Problem 1: Conceptual Design
-
-Design and create a database schema about publications. We will refer to this schema as `PubSchema`, and to the data as `PubData`.
-- E/R Diagram. Design the E/R diagram, consisting of the entity sets and relationships below. Draw the E/R diagram for this schema, identify all keys in all entity sets, and indicate the correct type of all relationships (many-many or many-one); make sure you use the ISA box where needed.
- - `Author` has attributes: `id` (a key; must be unique), `name`, and `homepage` (a URL)
- - `Publication` has attributes: `pubid` (the key -- an integer), `pubkey` (an alternative key, text; must be unique), `title`, and `year`. It has the following subclasses:
- - `Article` has additional attributes: `journal`, `month`, `volume`, `number`
- - `Book` has additional attributes: `publisher`, `isbn`
- - `Incollection` has additional attributes: `booktitle`, `publisher`, `isbn`
- - `Inproceedings` has additional attributes: `booktitle`, `editor`
- - There is a many-many relationship `Authored` from `Author` to `Publication`
- - Refer to Chapter 2, "Introduction to Database Design," and Chapter 3.5, "Logical Database Design: ER to Relational" in R&G if you need additional references.
-
-**Turn in** the file `pubER.pdf`
-
-## Problem 2: Schema Design
-
-Here you will create the SQL tables in a database in postgres. First, check that you have installed postgres on your computer. Then, create an empty database by running the following command:
-
-```sh
-$ createdb dblp
-```
-
-If you need to restart, then delete it by running:
-
-```sh
-$ dropdb dblp
-```
-
-To run queries in postgres, type:
-
-```sh
-$ psql dblp
-```
-then type in your SQL commands. Remember three special commands:
-
-```sh
-\q -- quit psql
-\h -- help
-\? -- help for meta commands
-```
-
-Next, design the SQL tables that implement your conceptual schema (the E/R diagram). We will call this database schema the `PubSchema`. Write `create Table` SQL statements, e.g.:
-
-```sql
-create Table Author (...);
-...
-```
-
-Choose `int` and `text` for all data types. Create keys, foreign
-keys, and unique constraints, as needed; you may either do it within
-`CREATE TABLE`, or postpone this for later and use `ALTER TABLE`. Do
-NOT use the `inherit` or `pivot` functionality in postgres, instead
-use the simple design principles discussed in class.
-
-Write all your commands in a file called `createPubSchema.sql`. You can execute them in two ways. Start postgres interactively and copy/paste your commands one by one. Or, from the command line run:
-
-```sh
-psql -f createPubSchema.sql dblp
-```
-
-Hint: for debugging purposes, insert `drop Table` commands at the beginning of the `createPubSchema.sql` file:
-
-```sql
-drop table if exists Author;
-...
-```
-
-**Turn in** the file `createPubSchema.sql`.
-
-
-## Problem 3: Data Acquisition
-
-Typically, this step consists of downloading data, or extracting it with a
-software tool, or inputting it manually, or all of the above. Then it involves
-writing and running some python script, called a *wrapper* that
-reformats the data into some CSV format that we can upload to the database.
-
-Download the DBLP data `dblp.dtd` and `dblp.xml.gz` from the dblp [website](http://dblp.uni-trier.de/xml/), then unzip the xml file.
-Make sure you understand what data the the big xml file contains: look inside by running:
-
-```sh
-more dblp.xml
-```
-
-If needed, edit the `wrapper.py` and update the correct location of `dblp.xml` and the output files `pubFile.txt` and `fieldFile.txt`, then run:
-
-```sh
-python wrapper.py
-```
-
-This will take several minutes, and produces two large files: `pubFile.txt` and `fieldFile.txt`. Before you proceed, make sure you understand what happened during this step, by looking inside these two files: they are tab-separated files, ready to be imported in postgres.
-
-Next, edit the file `createRawSchema.sql` in the starter code to point to the correct path of `pubFile.txt` and `fieldFile.txt`: they must be absolute paths, e.g. `/home/myname/mycourses/544/pubFile.txt`. Then run:
-
-```sh
-psql -f createRawSchema.sql dblp
-```
-
-This creates two tables, `Pub` and `Field`, then imports the data (which may take a few minutes). We will call these two tables `RawSchema` and `RawData` respectively.
-
-
-## Problem 4: Querying the Raw Data
-
-During typical data ingestion, you sometimes need to discover the true schema of the data, and for that you need to query the `RawData`.
-
-Start `psql` then type the following commands:
-
-```sql
-select * from Pub limit 50;
-select * from Field limit 50;
-```
-
-For example, go to the dblp [website](http://dblp.uni-trier.de/), check out this paper, search for `Henry M. Levy`, look for the "Vanish" paper, and export the entry in BibTeX format. You should see the following in your browser
-
-```bibtex
-@inproceedings{DBLP:conf/uss/GeambasuKLL09,
- author = {Roxana Geambasu and
- Tadayoshi Kohno and
- Amit A. Levy and
- Henry M. Levy},
- title = {Vanish: Increasing Data Privacy with Self-Destructing Data},
- booktitle = {18th {USENIX} Security Symposium, Montreal, Canada, August 10-14,
- 2009, Proceedings},
- pages = {299--316},
- year = {2009},
- crossref = {DBLP:conf/uss/2009},
- url = {http://www.usenix.org/events/sec09/tech/full_papers/geambasu.pdf},
- timestamp = {Thu, 15 May 2014 18:36:21 +0200},
- biburl = {http://dblp.org/rec/bib/conf/uss/GeambasuKLL09},
- bibsource = {dblp computer science bibliography, http://dblp.org}
-}
-```
-
-
-The **key** of this entry is `conf/uss/GeambasuKLL09`. Try using by running this SQL query:
-
-```sql
-select * from Pub p, Field f where p.k='conf/uss/GeambasuKLL09' and f.k='conf/uss/GeambasuKLL09'
-```
-
-
-Write SQL Queries to answer the following questions using `RawSchema`:
-
-- For each type of publication, count the total number of publications of that type. Your query should return a set of (publication-type, count) pairs. For example (article, 20000), (inproceedings, 30000), ... (not the real answer).
-
-- We say that a field *occurs* in a publication type, if there exists at least one publication of that type having that field. For example, `publisher` in `incollection`, but `publisher` does not occur in `inproceedings`. Find the fields that occur in *all* publications types. Your query should return a set of field names: for example it may return title, if title occurs in all publication types (article, inproceedings, etc. notice that title does not have to occur in every publication instance, only in some instance of every type), but it should not return publisher (since the latter does not occur in any publication of type inproceedings).
-
-- Your two queries above may be slow. Speed them up by creating appropriate indexes, using the CREATE INDEX statement. You also need indexes on `Pub` and `Field` for the next question; create all indices you need on `RawSchema`
-
-**Turn in** a file `solution.sql` consising of SQL queries and all their answers inserted as comments
-
-
-## Problem 5: Data Transformation.
-
-Next, you will transform the DBLP data from `RawSchema` to `PubSchema`. This step is sometimes done using an ETL tool, but we will just use several SQL queries. You need to write queries to populate the tables in `PubSchema`. For example, to populate `Article`, you will likely run a SQL query like this:
-
-```sql
-insert into Article (select ... from Pub, Field ... where ...);
-```
-
-The `RawSchema` and `PubSchema` are quite different, so you will need to go through some trial and error to get the transformation right. Here are a few hints (but your approach may vary):
-
-- create temporary tables (and indices) to speedup the data transformation. Remember to drop all your temp tables when you are done
-
-- it is very inefficient to bulk insert into a table that contains a key and/or foreign keys (why?); to speed up, you may drop the key/foreign key constraints, perform the bulk insertion, then `alter Table` to create the constraints.
-
-- `PubSchema` requires an integer key for each author and each publication. Use a `sequence` in postgres. For example, try this and see what happens:
-
-```sql
-create table R(a text);
-insert into R values ('a');
-insert into R values ('b');
-insert into R values ('c');
-create table S(id int, a text);
-create sequence q;
-insert into S (select nextval('q') as id, a from R);
-drop sequence q;
-select * from S;
-```
-- DBLP knows the Homepage of some authors, and you need to store these in the Author table. But where do you find homepages in `RawData`? DBLP uses a hack. Some publications of type `www` are not publications, but instead represent homepages. For example Hank's official name in DBLP is 'Henry M. Levy'; to find his homepage, run the following query (this should run very fast, 1 second or less, if you created the right indices):
-
-```sql
-select z.* from Pub x, Field y, Field z where x.k=y.k and y.k=z.k and x.p='www' and y.p='author' and y.v='Henry M. Levy';
-```
-
-Get it? Now you know Hank's homepage. However, you are not there yet. Some www entries are not homepages, but are real publications. Try this:
-
-```sql
-select z.* from Pub x, Field y, Field z where x.k=y.k and y.k=z.k and x.p='www' and y.p='author' and y.v='Dan Suciu'
-```
-
-Your challenge is to find out how to identify each author's correct Homepage. (A small number of authors have two correct, but distinct homepages; you may choose any of them to insert in Author)
-
-- What if a publication in `RawData` has two titles? Or two `publishers`? Or two `years`? (You will encounter duplicate fields, but not necessarily these ones.) You may pick any of them, but you need to work a little to write this in SQL.
-
-**Turn in** the file `importPubData.sql` containing several `insert`, `create Table`, `alter Table`, etc statements.
-
-## Problem 6: Run Data Analytic Queries
-
-Finally, you reached the fun part. Write SQL queries to answer the following questions:
-
-- Find the top 20 authors with the largest number of publications. (Runtime: under 10s)
-
-- Find the top 20 authors with the largest number of publications in STOC. Repeat this for two more conferences, of your choice. Suggestions: top 20 authors in SOSP, or CHI, or SIGMOD, or SIGGRAPH; note that you need to do some digging to find out how DBLP spells the name of your conference. (Runtime: under 10s.)
-
-- The two major database conferences are 'PODS' (theory) and 'SIGMOD Conference' (systems). Find
- - (a). all authors who published at least 10 SIGMOD papers but never published a PODS paper, and
- - (b). all authors who published at least 5 PODS papers but never published a SIGMOD paper. (Runtime: under 10s)
-
-- A decade is a sequence of ten consecutive years, e.g. 1982, 1983, ..., 1991. For each decade, compute the total number of publications in DBLP in that decade. Hint: for this and the next query you may want to compute a temporary table with all distinct years. (Runtime: under 1minute.)
-
-- Find the top 20 most collaborative authors. That is, for each author determine its number of collaborators, then find the top 20. Hint: for this and some question below you may want to compute a temporary table of coauthors. (Runtime: a couple of minutes.)
-
-- For each decade, find the most prolific author in that decade. Hint: you may want to first compute a temporary table, storing for each decade and each author the number of publications of that author in that decade. Runtime: a few minutes.
-
-- Find the institutions that have published most papers in STOC; return the top 20 institutions. Then repeat this query with your favorite conference (SOSP or CHI, or ...), and see which are the best places and you didn't know about. Hint: where do you get information about institutions? Use the Homepage information: convert a Homepage like <http://www.cs.washington.edu/homes/levy/> to <http://www.cs.washington.edu>, or even to www.cs.washington.edu; now you have grouped all authors from our department, and we use this URL as surrogate for the institution. Read about substring manipulation in postres, by looking up `substring`, `position`, and `trim`.
-
-
-**Turn in** SQL queries in the file called `solution.sql`.
-
-## Problem 7: Data Visualization.
-
-Here you are asked to create some histograms (graphs), by writing a python script that first runs a query, then produces a graph using the result of the query.
-
-Construct two histograms: the histogram of the number of collaborators, and the histogram of the number of publications. The first histograph will have these axes:
-
-- the X axis is a number X=1,2,3,...
-- the Y axis represents the number of authors with X collaborators: Y(0)= number of authors with 0 collaborators, Y(1) = number of authors with 1 collaborator, etc
-
-Similarly for the second histogram. Try using a log scale, or a log-log scale, and choose the most appropriate. Feel free to produce a very nice graph (not necessarily a histogram).
-
-Resources:
-- Accessing postgres from python [tutorial](https://wiki.postgresql.org/wiki/Psycopg2_Tutorial); see also `pythonpsql.py` in the starter code
-- [Plotpy library](https://plot.ly/python/)
-
-**Turn in** a file `graph.py` and the output it generated in a file `graph.pdf`
-
-# Submission Instructions
-<a name="submission"></a>
-
-We will be using `git`, a source code control tool, for distributing and submitting homework assignments in this class.
-This will allow you to download the code and instruction for the homework,
-and also submit the labs in a standardized format that will streamline grading.
-
-You will also be able to use `git` to commit your progress on the labs
-as you go. This is **important**: Use `git` to back up your work. Back
-up regularly by both committing and pushing your code as we describe below.
-
-Course git repositories will be hosted as a repository in [CSE's
-gitlab](https://gitlab.cs.washington.edu/), that is visible only to
-you and the course staff.
-
-## Getting started with Git
-
-There are numerous guides on using `git` that are available. They range from being interactive to just text-based.
-Find one that works and experiment -- making mistakes and fixing them is a great way to learn.
-Here is a [link to resources](https://help.github.com/articles/what-are-other-good-resources-for-learning-git-and-github)
-that GitHub suggests starting with. If you have no experience with `git`, you may find this
-[web-based tutorial helpful](https://try.github.io/levels/1/challenges/1).
-
-Git may already be installed in your environment; if it's not, you'll need to install it first.
-For `bash`/`Linux` environments, git should be a simple `apt-get` / `yum` / etc. install.
-More detailed instructions may be [found here](http://git-scm.com/book/en/Getting-Started-Installing-Git).
-Git is already installed on the CSE linux machines.
-
-If you are using Eclipse or IntelliJ, many versions come with git already configured.
-The instructions will be slightly different than the command line instructions listed but will work
-for any OS. For Eclipse, detailed instructions can be found at
-[EGit User Guide](http://wiki.eclipse.org/EGit/User_Guide) or the
-[EGit Tutorial](http://eclipsesource.com/blogs/tutorials/egit-tutorial).
-
-
-## Cloning your repository for homework assignments
-
-We have created a git repository that you will use to commit and submit your the homework assignments.
-This repository is hosted on the [CSE's GitLab](https://gitlab.cs.washington.edu) ,
-and you can view it by visiting the GitLab website at
-`https://gitlab.cs.washington.edu/cse544-2018wi/cse544-[your CSE or UW username]`.
-
-You'll be using this **same repository** for each of the homework assignments this quarter,
-so if you don't see this repository or are unable to access it, let us know immediately!
-
-The first thing you'll need to do is set up a SSH key to allow communication with GitLab:
-
-1. If you don't already have one, generate a new SSH key. See [these instructions](http://doc.gitlab.com/ce/ssh/README.html) for details on how to do this.
-2. Visit the [GitLab SSH key management page](https://gitlab.cs.washington.edu/profile/keys). You'll need to log in using your CSE account.
-3. Click "Add SSH Key" and paste in your **public** key into the text area.
-
-While you're logged into the GitLab website, browse around to see which projects you have access to.
-You should have access to `cse544-[your CSE or UW username]`.
-Spend a few minutes getting familiar with the directory layout and file structure. For now nothing will
-be there except for the `hw1` directory with these instructions.
-
-We next want to move the code from the GitLab repository onto your local file system.
-To do this, you'll need to clone the 544 repository by issuing the following commands on the command line:
-
-```sh
-$ cd [directory that you want to put your 544 assignments]
-$ git clone git@gitlab.cs.washington.edu:cse544-2018wi/cse544-[your CSE or UW username].git
-$ cd cse544-[your CSE or UW username]
-```
-
-This will make a complete replica of the repository locally. If you get an error that looks like:
-
-```sh
-Cloning into 'cse544-[your CSE or UW username]'...
-Permission denied (publickey).
-fatal: Could not read from remote repository.
-```
-
-... then there is a problem with your GitLab configuration. Check to make sure that your GitLab username matches the repository suffix, that your private key is in your SSH directory (`~/.ssh`) and has the correct permissions, and that you can view the repository through the website.
-
-Cloning will make a complete replica of the homework repository locally. Any time you `commit` and `push` your local changes, they will appear in the GitLab repository. Since we'll be grading the copy in the GitLab repository, it's important that you remember to push all of your changes!
-
-## Adding an upstream remote
-
-The repository you just cloned is a replica of your own private repository on GitLab.
-The copy on your file system is a local copy, and the copy on GitLab is referred to as the `origin` remote copy. You can view a list of these remote links as follows:
-
-```sh
-$ git remote -v
-```
-
-There is one more level of indirection to consider.
-When we created your `cse544-[your CSE or UW username]` repository, we forked a copy of it from another
-repository `cse544-2018wi`. In `git` parlance, this "original repository" referred to as an `upstream` repository.
-When we release bug fixes and subsequent homeworks, we will put our changes into the upstream repository, and you will need to be able to pull those changes into your own. See [the documentation](https://git-scm.com/book/en/v2/Git-Basics-Working-with-Remotes) for more details on working with remotes -- they can be confusing!
-
-In order to be able to pull the changes from the upstream repository, we'll need to record a link to the `upstream` remote in your own local repository:
-
-```sh
-$ # Note that this repository does not have your username as a suffix!
-$ git remote add upstream git@gitlab.cs.washington.edu:suciu/cse544-2018wi.git
-```
-
-For reference, your final remote configuration should read like the following when it's setup correctly:
-
-```sh
-$ git remote -v
- origin git@gitlab.cs.washington.edu:cse544-2018wi/cse544-[your CSE username].git (fetch)
- origin git@gitlab.cs.washington.edu:cse544-2018wi/cse544-[your CSE username].git (push)
- upstream git@gitlab.cs.washington.edu:suciu/cse544-2018wi.git (fetch)
- upstream git@gitlab.cs.washington.edu:suciu/cse544-2018wi.git (push)
-```
-
-In this configuration, the `origin` (default) remote links to **your** repository
-where you'll be pushing your individual submission. The `upstream` remote points to **our**
-repository where you'll be pulling subsequent homework and bug fixes (more on this below).
-
-Let's test out the origin remote by doing a push of your master branch to GitLab. Do this by issuing the following commands:
-
-```sh
-$ touch empty_file
-$ git add empty_file
-$ git commit empty_file -m 'Testing git'
-$ git push # ... to origin by default
-```
-
-The `git push` tells git to push all of your **committed** changes to a remote. If none is specified, `origin` is assumed by default (you can be explicit about this by executing `git push origin`). Since the `upstream` remote is read-only, you'll only be able to `pull` from it -- `git push upstream` will fail with a permission error.
-
-After executing these commands, you should see something like the following:
-
-```sh
-Counting objects: 4, done.
-Delta compression using up to 4 threads.
-Compressing objects: 100% (2/2), done.
-Writing objects: 100% (3/3), 286 bytes | 0 bytes/s, done.
-Total 3 (delta 1), reused 0 (delta 0)
-To git@gitlab.cs.washington.edu:cse544-2018wi/cse544-[your CSE or UW username].git
- cb5be61..9bbce8d master -> master
-```
-
-We pushed a blank file to our origin remote, which isn't very interesting. Let's clean up after ourselves:
-
-```sh
-$ # Tell git we want to remove this file from our repository
-$ git rm empty_file
-$ # Now commit all pending changes (-a) with the specified message (-m)
-$ git commit -a -m 'Removed test file'
-$ # Now, push this change to GitLab
-$ git push
-```
-
-If you don't know Git that well, this probably seemed very arcane. Just keep using Git and you'll understand more and more. We'll provide explicit instructions below on how to use these commands to actually indicate your final lab solution.
-
-## Pulling from the upstream remote
-
-If we release additional details or bug fixes for this homework,
-we'll push them to the repository that you just added as an `upstream` remote. You'll need to `pull` and `merge` them into your own repository. (You'll also do this for subsequent homeworks!) You can do both of these things with the following command:
-
-```sh
-$ git pull upstream master
-remote: Counting objects: 3, done.
-remote: Compressing objects: 100% (3/3), done.
-remote: Total 3 (delta 2), reused 0 (delta 0)
-Unpacking objects: 100% (3/3), done.
-From gitlab.cs.washington.edu:cse544-2018wi/cse544-2018wi
- * branch master -> FETCH_HEAD
- 7f81148..b0c4a3e master -> upstream/master
-Merge made by the 'recursive' strategy.
- README.md | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-```
-
-Here we pulled and merged changes to the `README.md` file. Git may open a text editor to allow you to specify a merge commit message; you may leave this as the default. Note that these changes are merged locally, but we will eventually want to push them to the GitLab repository (`git push`).
-
-Note that it's possible that there aren't any pending changes in the upstream repository for you to pull. If so, `git` will tell you that everything is up to date.
-
-
-## Collaboration
-
-All CSE 544 assignments are to be completed **INDIVIDUALLY**! However, you may discuss your high-level approach to solving each lab with other students in the class.
-
-## Submitting your assignment
-
-You may submit your code multiple times; we will use the latest version you submit that arrives
-before the deadline.
-Put all your files(`pubER.pdf`, `createPubSchema.sql`, `solution.sql`, `importPubData.sql`, `graph.py`, `graph.pdf`) in `hw1/submission`. Your directory structure should
-look like this after you have completed the assignment:
-
-```sh
-cse544-[your CSE or UW username]
-\-- README.md
-\-- turnInHW.sh # script for turning in hw
-\-- hw1
- \-- hw1.md # this is the file that you are currently reading
- \-- submission
- \-- pubER.pdf # your solution to question 1
- \-- createPubSchema.sql # your solution to question 2
- \-- solution.sql # your solution to question 3
- ...
-```
-
-**Important**: In order for your write-up to be added to the git repo, you need to explicitly add it:
-
-```sh
-$ cd submission
-$ git add pubER.pdf createPubSchema.sql ...
-```
-
-Or if you do
-```sh
-$ git add submission
-```
-
-Then it will add *all* the files inside the `submission` directory to the repo.
-
-The criteria for your homework being submitted on time is that your code must be tagged and
-pushed by the due date and time. This means that if one of the TAs or the instructor were to open up GitLab, they would be able to see your solutions on the GitLab web page.
-
-**Just because your code has been committed on your local machine does not mean that it has been submitted -- it needs to be on GitLab!**
-
-There is a bash script `turnInHw.sh` in the root level directory of your repository that commits your changes, deletes any prior tag for the current lab, tags the current commit, and pushes the branch and tag to GitLab. If you are using Linux or Mac OSX, you should be able to run the following:
-
-```sh
-$ ./turnInHw.sh hw1
-```
-
-You should see something like the following output:
-
-```sh
-$ ./turnInHw.sh hw1
-[master b155ba0] Homework 1
- 1 file changed, 1 insertion(+)
-Deleted tag 'hw1' (was b26abd0)
-To git@gitlab.com:cse544-2018wi/cse544-[your CSE or UW username].git
- - [deleted] hw1
-Counting objects: 11, done.
-Delta compression using up to 4 threads.
-Compressing objects: 100% (4/4), done.
-Writing objects: 100% (6/6), 448 bytes | 0 bytes/s, done.
-Total 6 (delta 3), reused 0 (delta 0)
-To git@gitlab.com:cse544-2018wi/cse544-[your CSE or UW username].git
- ae31bce..b155ba0 master -> master
-Counting objects: 1, done.
-Writing objects: 100% (1/1), 152 bytes | 0 bytes/s, done.
-Total 1 (delta 0), reused 0 (delta 0)
-To git@gitlab.com:cse544-2018wi/cse544-[your CSE or UW username].git
- * [new tag] hw1 -> hw1
-```
-
-
-## Final Word of Caution!
-
-Git is a distributed version control system. This means everything operates offline until you run `git pull` or `git push`. This is a great feature.
-
-The bad thing is that you may **forget to `git push` your changes**. This is why we strongly, strongly suggest that you **check GitLab to be sure that what you want us to see matches up with what you expect**. As a second sanity check, you can re-clone your repository in a different directory to confirm the changes:
-
-```sh
-$ git clone git@gitlab.cs.washington.edu:cse544-2018wi/cse544-[your CSE or UW username].git confirmation_directory
-$ cd confirmation_directory
-$ # ... make sure everything is as you expect ...
-```
\ No newline at end of file
diff --git a/hw/hw1/starter-code/createRawSchema.sql b/hw/hw1/starter-code/createRawSchema.sql
deleted file mode 100644
index 316aaa74dcf81a77c6b5ddc004bf7bd9f08f7164..0000000000000000000000000000000000000000
--- a/hw/hw1/starter-code/createRawSchema.sql
+++ /dev/null
@@ -1,4 +0,0 @@
-create table Pub (k text, p text);
-create table Field (k text, i text, p text, v text);
-copy Pub from 'pubFile.txt';
-copy Field from 'fieldFile.txt';
diff --git a/hw/hw1/starter-code/pythonpsql.py b/hw/hw1/starter-code/pythonpsql.py
deleted file mode 100644
index 37fe63d6f6f02be7f64ad58cc36766c216c6ce16..0000000000000000000000000000000000000000
--- a/hw/hw1/starter-code/pythonpsql.py
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/python
-import psycopg2
-
-def main():
- try:
- conn = psycopg2.connect("dbname='dblp' user='<YOUR USER NAME>' host='localhost' password=''")
- except psycopg2.Error, e:
- print "I am unable to connect to the database"
-
- cur = conn.cursor()
-
- cur.execute("SELECT * FROM author LIMIT 10")
-
- rows = cur.fetchall()
-
- print "Showing first 10 results:\n"
-
- for row in rows:
- print row[0], row[1]
-
-if __name__ == "__main__":
- main()
diff --git a/hw/hw1/starter-code/wrapper.py b/hw/hw1/starter-code/wrapper.py
deleted file mode 100644
index c38ab5e6ab7367c51bb9ec47fac45533ea7a4837..0000000000000000000000000000000000000000
--- a/hw/hw1/starter-code/wrapper.py
+++ /dev/null
@@ -1,60 +0,0 @@
-import xml.sax
-import re
-
-
-class DBLPContentHandler(xml.sax.ContentHandler):
- """
- Reads the dblp.xml file and produces two output files.
- pubFile.txt = (key, pubtype) tuples
- fieldFile.txt = (key, fieldCnt, field, value) tuples
- Each file is tab-separated
-
- Once the program finishes, load these two files in a relational database; run createSchema.sql
- """
-
- def __init__(self):
- xml.sax.ContentHandler.__init__(self)
-
-
- def startElement(self, name, attrs):
- if name == "dblp":
- DBLPContentHandler.pubFile = open('pubFile.txt', 'w')
- DBLPContentHandler.fieldFile = open('fieldFile.txt', 'w')
- DBLPContentHandler.pubList = ["article", "inproceedings", "proceedings", "book", "incollection", "phdthesis", "mastersthesis", "www"]
- DBLPContentHandler.fieldList = ["author", "editor", "title", "booktitle", "pages", "year", "address", "journal", "volume", "number", "month", "url", "ee", "cdrom", "cite", "publisher", "note", "crossref", "isbn", "series", "school", "chapter"]
- DBLPContentHandler.content = ""
- if name in DBLPContentHandler.pubList:
- DBLPContentHandler.key = attrs.getValue("key")
- DBLPContentHandler.pub = name
- DBLPContentHandler.fieldCount = 0
- DBLPContentHandler.content = ""
- if name in DBLPContentHandler.fieldList:
- DBLPContentHandler.field = name
- DBLPContentHandler.content = ""
-
- def endElement(self, name):
- if name in DBLPContentHandler.fieldList:
- DBLPContentHandler.fieldFile.write(DBLPContentHandler.key)
- DBLPContentHandler.fieldFile.write("\t")
- DBLPContentHandler.fieldFile.write(str(DBLPContentHandler.fieldCount))
- DBLPContentHandler.fieldFile.write( "\t")
- DBLPContentHandler.fieldFile.write(DBLPContentHandler.field)
- DBLPContentHandler.fieldFile.write("\t")
- DBLPContentHandler.fieldFile.write(DBLPContentHandler.content)
- DBLPContentHandler.fieldFile.write("\n")
- DBLPContentHandler.fieldCount += 1
- if name in DBLPContentHandler.pubList:
- DBLPContentHandler.pubFile.write(DBLPContentHandler.key)
- DBLPContentHandler.pubFile.write("\t")
- DBLPContentHandler.pubFile.write(DBLPContentHandler.pub)
- DBLPContentHandler.pubFile.write("\n")
-
- def characters(self, content):
- DBLPContentHandler.content += content.replace('\\','\\\\')
-
-def main(sourceFileName):
- source = open(sourceFileName)
- xml.sax.parse(source, DBLPContentHandler())
-
-if __name__ == "__main__":
- main("dblp.xml")
diff --git a/hw/hw1/submission/README b/hw/hw1/submission/README
deleted file mode 100644
index afe7dafe3331dc31a88535ef4732db23604b6833..0000000000000000000000000000000000000000
--- a/hw/hw1/submission/README
+++ /dev/null
@@ -1 +0,0 @@
-put your .sql files in this directory, one file per question.
diff --git a/hw/hw2/figs/ra.pdf b/hw/hw2/figs/ra.pdf
deleted file mode 100644
index 2f0dcf64b602dab59c96c1864b22e18b35c307f5..0000000000000000000000000000000000000000
Binary files a/hw/hw2/figs/ra.pdf and /dev/null differ
diff --git a/hw/hw2/figs/ra.pptx b/hw/hw2/figs/ra.pptx
deleted file mode 100644
index 8be76e6b7d021846d25f63faefa58741890e070d..0000000000000000000000000000000000000000
Binary files a/hw/hw2/figs/ra.pptx and /dev/null differ
diff --git a/hw/hw2/hw2.md b/hw/hw2/hw2.md
deleted file mode 100644
index 006d83373a7269a6e39fbd3c7d91b0db024b8473..0000000000000000000000000000000000000000
--- a/hw/hw2/hw2.md
+++ /dev/null
@@ -1,146 +0,0 @@
-# CSE 544 Homework 2: Finding the Mitochondrial Eve
-
-**Objectives:**
-To understand how queries are translated into the relational algebra. To master writing relational queries in a logic formalism using datalog.
-
-**Assignment tools:**
-Part 1: pen and paper; Part 2: Soufflé
-
-**Assigned date:** January 21st, 2018
-
-**Due date:** February 2nd, 2018
-
-**What to turn in:** `hw2-q1.txt`, `hw2-q2.txt`, `hw2-q3.dl` along with its output `hw2-q3-1.ans`, `hw2-q3-2.ans`, `hw2-q3-3.ans`, `hw2-q3-4.ans`, `hw2-q3-5.ans`(see details below)
-
-**Resources:**
-
-- Soufflé (https://github.com/souffle-lang/souffle)
-
-- Soufflé [language documentation](http://souffle-lang.org/docs/datalog/)
-
-- [Soufflé tutorial](http://souffle-lang.org/pdf/SoufflePLDITutorial.pdf)
-
-- Starter code in your personal repo for Part 2.
-
-- General information for Part 2:
- - The [Mitochondrial Eve](https://en.wikipedia.org/wiki/Mitochondrial_Eve)
- - List of [women in the Bible](https://en.wikipedia.org/wiki/List_of_women_in_the_Bible)
- - List of [minor biblical figures](https://en.wikipedia.org/wiki/List_of_minor_biblical_figures,_A%E2%80%93K)
- - Note that the parent-child relationship is randomly generated and may change.
-
-
-## Assignment Details
-
-### Part 1: Warm Up with Relational Algebra
-
-1. (10 points) Write the equivalent SQL query to this [relational algebra plan](figs/ra.pdf "Relational Algebra Plan"). Save your answer in `hw2-q1.txt`.
-
-2. (10 points) Write a relational algebra plan for the following SQL query:
-
- ```sql
- select a.p
- from person_living a, male b
- where a.p = b.name and
- not exists (select *
- from parent_child c, female d
- where c.p1=d.name and c.p2=a.p)
- ```
-
- You do not need to draw the query plan as a tree and can use the linear style instead. To make precedence clear, we ask you to break down your query plan by using *at most one* operator on each line. For example, given the query in question 1, you could write it as:
-
- ```sh
- T1(x,p1,p2) = person_living(x) Join[x=p1] parent_child(p1,p2)
- T2(p3,p4) = rename[p3,p4] parent_child(p3,p4)
- T3(x,p1,p2,p3,p4) = T1(x,p1,p2) Join[p2=p3] T2(p3,p4)
- T4(p1,p2,y) = GroupBy[p1,p2,count(*)->y] T3(x,p1,p2,p3,p4)
- T5(p1,z) = GroupBy[p1,max(y)->z] T4(p1,p2,y)
- ```
-
- where `T1`, `T2`, etc are temporary relations. Note that each line has at most one relational operator. You do not need to use the Greek symbols if you prefer. You also don't need to distinguish among the different flavors of join (just make sure that you write out the full join predicate).
-
- Save your answer in `hw2-q2.txt`.
-
-
-### Part 2. Finding the Mitochondrial Eve
-
-Every human has a mother, who had her own mother, who in turn had her own mother. The matrilineal ancestor of an individual consists of the mother, the mother’s mother, and so on, following only the female lineage. A matrilinial common ancestor, MCA, is a matrilinial ancestor of all living humans. An MCA is very, very likely to exist (why?), and in fact there are many MCAs. The matrilineal most recent ancestor, or MRCA, is the only individual (woman) who is the MCA of all living humans and is the most recent such. Who is she? When did she live? In the 1980s three researchers, Cann, Stoneking and Wilson, analyzed the mitocondrial DNA of living humans and determined that the MRCA lived about 200,000 years ago. The researchers called her the [Mithcondrial Eve](https://en.wikipedia.org/wiki/Mitochondrial_Eve).
-
-In this homework, you will analyze a database of 800 individuals, compute several things, culminating with the the computation of the Mithocondrial Eve. The genealogy database consists of over 800 biblical names, obtained from Wikipedia, with a randomly generated parent-child relationship.
-
-### Getting Started
-
-1. Install Soufflé
- 1. **Mac user**
- * Download the [souffle-1.2.0.pkg](https://github.com/souffle-lang/souffle/releases/tag/1.2.0)
- 2. **Windows user**
- * To ease the installation process, we recommand using the pre-built version of Soufflé on Debian
- * Download the [VMPlayer](https://my.vmware.com/en/web/vmware/free#desktop_end_user_computing/vmware_workstation_player/12_0)
- * Download the [Debian Image](https://www.debian.org/distrib/netinst). Make sure you install the amd64 version.
- * When VMplayer starts running, click on the "Open a Virtual Machine" link. Navigate to the folder where you sotre the Debian Image. Click "OK". Then click on the left-side tab that appears containing the VM name. Click "Play virtual machine".
- * When Debian is setup, obtain the pre-built package [souffle_1.2.0-1_amd64.deb](https://github.com/souffle-lang/souffle/releases/tag/1.2.0)
- * Open a terminal and navigate to the location where you downloaded the package (which is probably `~/Downloads`)
- * Then type `sudo apt install ./souffle_1.2.0-1_amd64.deb`
-
-2. Verify Soufflé is working:
- ```
- $ cd hw2/starter-code
- $ souffle hw2-q3.dl
- ```
-
- Congratulations! You just ran your first datalog query.
-
-### Questions
-For each question below, write in the file `hw2-q3.dl` a program that computes the answer to that question. See the Example section below.
-
-1. (10 points) Find all descendants of Priscilla and their descriptions. Name your predicate `p1(x,d)`. Write the output to a file called `hw2-q3-1.ans`(123 rows)
-
-
-2. (10 points) Find the woman/women with the largest number of children and the man/men with the largest number of children. For each individual, you should return the name of that individual, his/her description, and the number of children. Name your predicate `p2(x,d,n)`. Write the output to a file called `hw2-q3-2.ans`(2 rows)
-
-
-3. (20 points) For each person x, we call a "complete lineage" any sequence x0=x, x1, x2, … , xn where each person is the parent of the previous person, and the last person has no parents; the length of the sequence is n. If x has a complete lineage of length n, then we also say that "x is in generation n". Compute the minimum and maximum generation of each living person x.
-
- Name your predicate `p3(x,m1,m2)`, where x is a living person, and `m1`, `m2` are the minimal/maximal generation. (Hint: You may want to first compute all generations for all x: think about when can you say that x is in generation 0, and when can you say that x is in generation n+1. Of course x can be in multiple generations, e.g., x's mother is in generation 0 and x's father is in generation 2. Once you know everybody's generations, you can answer the problem easily.) Write the output to a file called `hw2-q3-3.ans` (22 rows)
-
-4. (20 points) Compute all matrilineal common ancestors, MCA. Name your predicate `p4(x)`. Write the output to a file called `hw2-q3-4.ans` (6 rows)
-
-5. (20 points) Find the mitochondrial Eve. Name your predicate `p5(x)`. Remember that you can utilize your predicates defined earlier. Write the output to a file called `hw2-q3-5.ans` (1 row)
-
-
-#### Example
-
-For example, suppose the question were: find all children of Priscilla; return their names and their descriptions. Then you write this in the `hw3-q3.dl` file (it’s already there):
-
-```c
-.output p0(IO=stdout)
-p0(x,d) :- parent_child("Priscilla",x), person(x,d). //NOTE the period at the end
-```
-
-## Submission Instructions
-
-For Part 1, write your answers in a file `hw4-q1.txt`, and `hw4-q2.txt`.
-
-For part 2, write your answers in the provided file `hw2-q3.dl` and name the output generated from p1, p2, p3, p4, p5: `hw2-q3-1.ans`, `hw2-q3-2.ans`, `hw2-q3-3.ans`, `hw2-q3-4.ans`, `hw2-q3-5.ans`
-
-**Important**: To remind you, in order for your answers to be added to the git repo,
-you need to explicitly add each file:
-
-```sh
-$ git add *.txt *.ans
-```
-
-**Again, just because your code has been committed on your local machine does not mean that it has been
-submitted -- it needs to be on GitLab!**
-
-Use the same bash script `turnInHw.sh` in the root level directory of your repository that
-commits your changes, deletes any prior tag for the current lab, tags the current commit,
-and pushes the branch and tag to GitLab.
-
-If you are using Linux or Mac OSX, you should be able to run the following:
-
-```sh
-$ ./turnInHw.sh hw2
-```
-
-Like previous assignments, make sure you check the results afterwards to make sure that your file(s)
-have been committed.
diff --git a/hw/hw2/starter-code/DATA/female.facts b/hw/hw2/starter-code/DATA/female.facts
deleted file mode 100644
index 0061cd51a12d26704349f7a1eaef2b604a9231a0..0000000000000000000000000000000000000000
--- a/hw/hw2/starter-code/DATA/female.facts
+++ /dev/null
@@ -1,182 +0,0 @@
-Leah
-Mahlah #2
-Mahlah #1
-Abital
-Milcah #2
-Milcah #1
-Jehudijah
-Matred
-Jerusha
-Noah
-Hammolekheth
-Athaliah
-Achsah (or Acsah)
-Queen Vashti
-Mahalath #1
-Deborah #2
-Meshullemeth
-Abishag
-Timnah (or Timna)
-Zillah #2
-Elisabeth
-Lois, grandmother of Saint Timothy. II Timothy[101]
-Aholibamah (or Oholibamah)
-Naomi
-Eglah
-Abigail #4
-Abigail #3
-Haggith
-Rhoda
-Lo-Ruhamah
-Zilpah
-Jehosheba (or Jehoshebeath/Josaba)
-Jemima
-Helah
-Maacah
-Asenath
-Jerusha #2
-Eve
-Zillah
-Abihail #2
-Abihail #1
-Hagar
-Michal
-Mahalath
-Susanna #1
-Susanna #2
-Shiphrah
-Tamar #3
-Jemima #2
-Rizpah
-Zipporah
-Jehoaddan
-Antiochus
-Azubah #1
-Azubah #2
-Delilah
-Deborah #1
-Medium of En Dor
-Zeresh
-Baara
-Adah
-Mehetabeel
-Merab #2
-Mehetabel #2
-Jezebel #1
-Jezebel #2
-Esther (also known as Hadassah)
-Baara #2
-Orpah
-Martha
-Keziah
-Salome #2
-Salome #1
-Mehetabel
-Rebekah
-Lo–Ruhamah
-Reumah
-Bathsheba
-Jezebel
-Basemeth #1
-Basemeth #3
-Basemeth #2
-Tirzah
-Puah
-Euodia
-Hushim #2
-Damaris. Acts[41]
-Naamah #2
-Hannah
-Syntyche
-Me-Zahab
-Mahalath #2
-Diblaim
-Miriam #1
-Keziah #2
-Miriam #2
-Shelomith
-Ephrath
-Jael
-Ahlai #1
-Ahlai #2
-Noadiah
-Tabitha (Acts 9:36)
-Taphath
-Cozbi
-Tamar #1
-Tamar #2
-Elisheba #2
-Jehoaddan (or Jehoaddin)
-Rahab
-Elisheba
-Hogla (or Hoglah)
-Mary #1
-Mary #3
-Mary #2
-Mary #5
-Mary #4
-Mary #6
-Dinah
-Taphath #2
-Phoebe
-Junia or Junias
-Iscah
-Priscilla
-Ahinoam #2
-Ahinoam #1
-Naarah
-Hodiah's wife
-Mahlah
-Lydia of Thyatira
-Hephziba
-Shelomit #1
-Basemath
-Shelomit #2
-Jecholiah (or Jecoliah)
-Reumah #2
-Rachel
-Jerioth #2
-Jochebed
-Atarah
-Persis
-Merab
-Matred #2
-Anah
-Jerioth
-Claudia #2
-Julia
-Maacah #2
-Iscah #2
-Judith
-Hazelelponi (or Hazzelelponi)
-Eunice
-Bithiah
-Nehushta
-Sarah #2
-Jecholiah
-Sarah #1
-Dorcas, also known as Tabitha. Acts[46]
-Julia #2
-Anna the Prophetess
-Keren–Happuch
-Claudia
-Candace
-Sheerah
-Huldah
-Keturah
-Jedidah
-Eglah #2
-Adah # 1
-Adah #2
-Gomer
-Ruth
-Hodesh
-Peninnah
-Joanna
-Ephah
-Hamutal
-Bilhah
-Sapphira
-Zeruiah
-Hodesh #2
-Naamah #1
diff --git a/hw/hw2/starter-code/DATA/male.facts b/hw/hw2/starter-code/DATA/male.facts
deleted file mode 100644
index 8e42b1447ef4c433d91ca21e102b90b547ebb626..0000000000000000000000000000000000000000
--- a/hw/hw2/starter-code/DATA/male.facts
+++ /dev/null
@@ -1,670 +0,0 @@
-Persian 'مهمان signifies a stranger or guest' [17] Melatiah
-Ethnan
-Ibneiah
-Iphdeiah
-Bidkar
-Elioenai
-Ishhod
-Hashubah
-Joshbekashah
-Ebed-melech
-Milalai
-Malcam
-Maon
-Ehi
-Ishui
-Jimnah
-Bechorath
-Jaareshiah
-Raamiah
-Dalphon
-Ethni
-Elzaphan
-Muppim
-Hiel
-Elpaal
-Ishiah
-Adlai
-Dibri
-Ophir
-Igdaliah
-Josiphiah
-Jarha
-Appaim
-Ahimoth
-Ishuah
-Adbeel
-Adalia
-Hajehudijah
-Shuthelah
-Harumaph
-Jehizkiah
-Ahinadab
-Hoham
-Amasiah
-Amminadib
-Ahasbai
-Jehallelel
-Jokim
-Deuel
-Hammelech
-Eubulus
-Helon
-Ahiezer
-Semachiah
-Igal
-Gideon
-Machbanai
-Ithmah
-Pul
-Rinnah
-Shillem
-Jeriel
-Naharai
-Zedekiah
-Kelal
-Meshillemoth
-Jeiel
-Alvah
-Aiah
-Jidlaph
-Jehudi
-Ithran
-Jaanai
-Amon
-Isui
-Haddad
-Imla
-Ocran
-Ribai
-Simon Iscariot
-Habazziniah
-Hashabnah
-Elimelech
-Amos
-Becher
-Shemeber
-Hathach
-Eran
-Ahi
-Gaddiel
-Zephon
-Naphtuhim
-Anani
-Jehiah
-Jareb
-Aggaba
-Gilalai
-Narcissus
-Obal
-Shammah
-Jeshohaiah
-Jeuel
-Dishan
-Mehuman
-Hashub
-Azaniah
-Jehush
-Harhaiah
-Jahleel
-Shemida
-Evi
-Maasiai
-Elidad
-Phallu
-Rephael
-Libni
-Abdi
-Hasadiah
-Ziphion
-Rabmag
-Magpiash
-Shimeah
-Ephlal
-Malchiah
-Hagab
-Nepheg
-Harhas
-Joezer
-Izhar
-Mehujael
-Matthan
-Uriah ben Shemaiah
-Izrahiah
-Stachys
-Isshiah
-Jishui
-Hachmoni
-Vophsi
-Jacan
-Ahishar
-Parnach
-Jeremai
-Keren-happuch
-Shelomi
-Kelita
-Diklah
-Athlai
-Harnepher
-Maai
-Matthat
-Hoshama
-Mishmannah
-Zeri
-Sachar
-Jamlech
-Joed
-Jaziz
-Birsha
-Jarah
-Joel
-Malchiel
-Moza
-Allon
-Q
-Rekem
-Jecamiah
-Gemalli
-Jahzeel
-Zabad
-Jekamiah
-Abinadab
-Pethahiah
-Sharar
-Sheconiah
-Immer
-Irijah
-Mahazioth
-Ben Hesed
-Linus
-Amzi
-Jaresiah
-Likhi
-Ishpan
-Ishpah
-Harum
-Heldai
-Hazo
-Tola
-Meshelemiah
-Mehir
-Kemuel
-Ilai
-Zuar
-Putiel
-Salu
-Helek
-Carmi
-Jozachar
-Meshullam
-Machnadebai
-Paseah
-Piram
-Caleb, son of Hezron
-Zichri
-Michael
-Jezer
-Vaniah
-Nebat
-Chenaanah
-Hallohesh
-Arodi
-Eri
-Ezrah
-Ahishahar
-Shedeur
-Ahasai
-Adna
-Abdeel
-Joshah
-Arnan
-Chelal
-Elzabad
-Rosh
-Mahali
-Joshibiah
-Pelatiah
-Romamti-ezer
-Jaasau
-Jaasai
-Ibnijah
-Elead
-Elionenai
-Shaphat
-Hezekiah
-Meremoth
-Shaashgaz
-Job
-Habaiah
-Hakkoz
-Melech
-Hubbah
-Mibsam
-Ahab
-Machbena
-Dodo
-Uri
-Enoch
-Mash
-Segub
-Sered
-Jeshishai
-Bukki
-Mijamin
-Seled
-Lahmi
-Delaiah
-Hori
-Ziza
-Jesui
-Elon
-Gazez
-Ishvi
-Aphiah
-Aduel
-Guni
-Aristobulus
-Izri
-Eleasah
-Izziah
-Ashbel
-Ahzai
-Hazaiah
-Mithredath
-Ben Hur
-Iram
-Hattil
-Jahmai
-Carshena
-Levi
-Irad
-Lo-Ammi
-Ittai
-Enan #2
-Enan #1
-Phalti
-Adnah
-Alexander
-Raphu
-Homam
-Abitub
-Azaliah
-Jozabad
-Harim
-Rohgah
-Jeush
-Jerijah
-Mishael
-Hagabah
-Mattatha
-Shechem
-Jathniel
-Kolaiah
-Ahisamach
-Malluch
-Jobab
-Amasa
-Melea
-Pelaiah
-Joiarib
-Zebadiah
-Ben Deker
-Joshua the Bethshemite
-Gera
-Seba
-Ozem
-Urijah
-Hasupha
-Shemaiah
-Ikkesh
-Darda
-Ahiram
-Zaccur
-Jaasu
-Ithai
-Zabdi
-Maadai
-Rephaiah
-Arah
-Ahuzzam
-Nephish
-Chalcol
-Jephunneh
-Admin
-Maaziah
-Genubath
-Shuni
-Elnaam
-Shinab
-Henadad
-Shaaph
-Melzar
-Ishvah
-Beno
-Haahashtari
-Shimi
-Hadlai
-Jediael
-Ibsam
-Naggai
-Miniamin
-Minjamin
-Alvan
-Shobal
-Shammua
-Shobab
-Jasiel
-Ephron
-Elishaphat
-Sodi
-Jogli
-Imna
-Miamin
-Eliathah
-Jehoaddah
-Nekoda
-Nereus
-Pelaliah
-Shearjashub
-Matri
-Geber
-Hermogenes
-Mallothi
-Hadadezer
-Jehoshaphat
-Rehum
-Idbash
-Zeror
-Nemuel
-Bigtha
-Abida
-Moab
-Shelumiel
-Obadiah
-Sabtah
-Antothijah
-Ozni
-Joshaviah
-Elihoreph
-Machi
-Zephaniah
-Heber
-Hotham
-Shimron
-Jalon
-Ner
-Shemer
-Kallai
-Jaaziel
-Meres
-Mahath
-Gatam
-Elizur
-Ishod
-Jeshaiah
-Jekameam
-Eliphal
-Peresh
-Nedabiah
-Aedias
-Vaizatha
-Parmashta
-Ginath
-Ishmerai
-Gaddi
-Peleth
-Malchi-shua
-Regem
-Aharhel
-Zabud
-Hamul
-Jesimiel
-Ajah
-Ishbah
-Laadah
-Gideoni
-Ammizabad
-Assir
-Ahilud
-Matthanias
-Gemariah
-Hareph
-Pethuel
-Areli
-Meraioth
-Chuza
-Neariah
-Haran
-Hezron
-Imri
-Meraiah
-Haggi
-Nahath
-Zuriel
-Admatha
-Jehozabad
-Hakkatan
-Elmadam
-Raddai
-Beriah
-Huzzab
-Naboth
-Molid
-Tahan
-Joash
-Japhia
-On
-Elienai
-Elpalet
-Hammoleketh
-Iru
-Ithream
-Iri
-Jehdeiah
-Asiel
-Shimshai
-Rezon
-Hanniel
-Hashabiah
-Maadiah
-Akan
-Rakem
-Hanoch
-Huppim
-Hananiah
-Baanah
-Azgad
-Jehubbah
-Eliada
-Pedahzur
-Johanan son of Kareah
-Chimham
-Ben Abinadab
-Helkai
-Hasrah
-Phaltiel
-Pedahel
-Zaavan
-Melchi
-Amaziah
-Naum
-Anan
-Anak
-Michri
-Nahum
-Ir
-Jahzerah
-Asriel
-Elizaphan
-Elpelet
-Hammedatha
-Nahbi
-Joelah
-Dodavahu
-Jeezer
-Josibiah
-Shaharaim
-Elishama
-Saph
-Tryphosa
-Azzan
-Nobah
-Barachel
-Laish
-Jushab-hesed
-Jonathan son of Kareah
-Hushim
-Zithri
-Shephatiah
-Aziel
-Naphish
-Marsena
-Elasah
-Jezrahiah
-Poratha
-Tyrannus
-Shisha
-Imrah
-Ishuai
-Paruah
-Phurah
-Eluzai
-Mibhar
-Ard
-Jekuthiel
-Pinon
-Phuvah
-Chelub
-Ahitub
-Zippor
-Harbona
-Jibsam
-Jerah
-Palti
-Abijah
-Hothir
-Ahian
-Hemam
-Ben-Ammi
-Hiram
-Eliadah
-Geuel
-Gamaliel
-Nehum
-Merib-baal
-Zohar
-Jahzeiah
-Sabtechah
-Shiphtan
-Jakeh
-Naaman
-Azariah
-Ahlai
-Athaiah
-Ezbon
-Nogah
-Sachia
-Eliasaph
-Parshandatha
-Paltiel
-Jeatherai
-Reba
-Eldaah
-Jaasiel
-Agee
-Letushim
-Anaiah
-Jezoar
-Mnason
-Lael
-Ismaiah
-Barkos
-Regem-melech
-Abimael
-Zidkijah
-Ephod
-Karshena
-Jeziah
-Mushi
-Ramiah
-Zurishaddai
-Zerah
-Jamin
-Obil
-Ben Geber
-Chenaniah
-Sethur
-Ishbi-benob
-Jesher
-Rehabiah
-Maaseiah
-Akkub
-Eshek
-Hamor
-Jekoliah
-Abdon
-Shemuel
-Adina
-Nebuzaradan
-Shelemiah
-Jehiel
-Abiel
-Zobebah
-Isshijah
-Pildash
-Uel
-Jehoiada
-Pagiel
-Maher-shalal-hash-baz
-Zalmon
-Ishijah
-Bela
-Joahaz
-Ahuzzath
-Susi
-Joseph
-Joshua the governor of the city
-Peulthai
-Hod
-Ispah
-Hon
-Mezahab
-Chelluh
-Shabbethai
-Asareel
-Barzillai
-Judas of Straight Street in Damascus
-Jahaziah
-Abiasaph
-Massa
-Elnathan
-Sheshan
-Hodaviah
-Janai
-Hillel
-Jakim
-Jeriah
-Eliphelet
-Gishpa
-Jemuel
-Sarsekim
-Hepher
-Hathath
-Ebed
-Shagee
-Jonathan son of Abiathar
-Michaiah
-Chislon
-Jachin
-Ziphah
-Mikloth
-Hanameel
-Ishmaiah
-Hobab
-Jahath
-Methushael
-Leummim
-Gamul
-Mahol
-Jarib
-Jaaziah
diff --git a/hw/hw2/starter-code/DATA/parent_child.facts b/hw/hw2/starter-code/DATA/parent_child.facts
deleted file mode 100644
index 1ad5be9adfcf426a21cbef414e06dcc9c12ebf01..0000000000000000000000000000000000000000
--- a/hw/hw2/starter-code/DATA/parent_child.facts
+++ /dev/null
@@ -1,1658 +0,0 @@
-Noah Jahath
-Ahasai Jahath
-Noah Zobebah
-Azgad Zobebah
-Jerusha #2 Ishbi-benob
-Mehir Ishbi-benob
-Mahalath #2 Ben Geber
-Hammedatha Ben Geber
-Noah Jezoar
-Hattil Jezoar
-Mahalath #2 Nogah
-Jephunneh Nogah
-Mahalath #2 Sarah #1
-Hammedatha Sarah #1
-Rebekah Judith
-Hillel Judith
-Jerusha #2 Persis
-Eliasaph Persis
-Rebekah Kallai
-Jaresiah Kallai
-Mahalath #2 Ner
-Mehir Ner
-Noah Tabitha (Acts 9:36)
-Azgad Tabitha (Acts 9:36)
-Jerusha #2 Hadlai
-Akan Hadlai
-Jerusha #2 Shuni
-Azgad Shuni
-Noah Joshua the Bethshemite
-Hammedatha Joshua the Bethshemite
-Noah Aristobulus
-Ahasai Aristobulus
-Rebekah Aphiah
-Ahasai Aphiah
-Mahalath #2 Delilah
-Hillel Delilah
-Noah Hasadiah
-Hattil Hasadiah
-Mahalath #2 Jemima
-Hillel Jemima
-Mahalath #2 Hashub
-Jephunneh Hashub
-Mahalath #2 Gaddiel
-Elmadam Gaddiel
-Rebekah Ocran
-Jephunneh Ocran
-Noah Alvah
-Elmadam Alvah
-Mahalath #2 Jeiel
-Elmadam Jeiel
-Jerusha #2 Jeriel
-Ishpan Jeriel
-Delilah Mikloth
-Mehir Mikloth
-Noah Ispah
-Elmadam Ispah
-Jerusha #2 Ishijah
-Levi Ishijah
-Judith Peninnah
-Amasa Peninnah
-Jemima Chenaniah
-Gaddiel Chenaniah
-Delilah Letushim
-Ishpan Letushim
-Noah Hothir
-Zobebah Hothir
-Sarah #1 Nahum
-Jeriel Nahum
-Persis Huppim
-Ner Huppim
-Jemima Maadiah
-Leummim Maadiah
-Judith Peresh
-Jaresiah Peresh
-Mahalath #2 Jekameam
-Alvah Jekameam
-Mahalath #2 Mary #3
-Bechorath Mary #3
-Sarah #1 Ahisamach
-Nogah Ahisamach
-Mahalath #2 Guni
-Gaddiel Guni
-Judith Ishvi
-Hammedatha Ishvi
-Persis Mehetabel
-Hillel Mehetabel
-Persis Segub
-Azgad Segub
-Persis Hallohesh
-Jephunneh Hallohesh
-Mahalath #2 Adah
-Hammedatha Adah
-Judith Ilai
-Akan Ilai
-Tabitha (Acts 9:36) Likhi
-Levi Likhi
-Mahalath #2 Moza
-Ocran Moza
-Tabitha (Acts 9:36) Lo-Ruhamah
-Levi Lo-Ruhamah
-Mahalath #2 Zephon
-Akan Zephon
-Delilah Elisabeth
-Ishpan Elisabeth
-Persis Shillem
-Aphiah Shillem
-Noah Meshullemeth
-Elmadam Meshullemeth
-Tabitha (Acts 9:36) Helon
-Hashub Helon
-Adah Ephah
-Letushim Ephah
-Peninnah Sethur
-Ahisamach Sethur
-Adah Abijah
-Letushim Abijah
-Jemima Chelub
-Zobebah Chelub
-Mehetabel Ithream
-Likhi Ithream
-Persis Molid
-Likhi Molid
-Elisabeth Naboth
-Joshua the Bethshemite Naboth
-Jemima Ozni
-Shuni Ozni
-Elisabeth Nemuel
-Letushim Nemuel
-Meshullemeth Jehoshaphat
-Huppim Jehoshaphat
-Sarah #1 Rahab
-Nogah Rahab
-Sarah #1 Jehoaddah
-Huppim Jehoaddah
-Peninnah Jehoaddan (or Jehoaddin)
-Ben Geber Jehoaddan (or Jehoaddin)
-Delilah Maaziah
-Hallohesh Maaziah
-Delilah Naamah #2
-Jekameam Naamah #2
-Tabitha (Acts 9:36) Hushim #2
-Shillem Hushim #2
-Mary #3 Jathniel
-Ishijah Jathniel
-Lo-Ruhamah Hagabah
-Peresh Hagabah
-Elisabeth Enan #1
-Ner Enan #1
-Lo-Ruhamah Aduel
-Shuni Aduel
-Adah Keziah
-Hasadiah Keziah
-Judith Zeresh
-Guni Zeresh
-Adah Joezer
-Ispah Joezer
-Judith Rhoda
-Ben Geber Rhoda
-Meshullemeth Ithran
-Moza Ithran
-Sarah #1 Shuthelah
-Peresh Shuthelah
-Mehetabel Josiphiah
-Shillem Josiphiah
-Mary #3 Elpaal
-Alvah Elpaal
-Hushim #2 Eliphelet
-Jehoshaphat Eliphelet
-Mary #3 Chelluh
-Ithran Chelluh
-Mehetabel Shelemiah
-Ispah Shelemiah
-Jehoaddan (or Jehoaddin) Paruah
-Segub Paruah
-Mary #3 Jecholiah
-Chenaniah Jecholiah
-Naamah #2 Asriel
-Ithream Asriel
-Lo-Ruhamah Merab
-Helon Merab
-Lo-Ruhamah Elpalet
-Shuthelah Elpalet
-Jehoaddan (or Jehoaddin) Rachel
-Letushim Rachel
-Zeresh Vaizatha
-Nahum Vaizatha
-Rahab Shemer
-Shillem Shemer
-Ephah Elnaam
-Mikloth Elnaam
-Hushim #2 Ithai
-Ozni Ithai
-Hushim #2 Raphu
-Huppim Raphu
-Ephah Baara #2
-Nahum Baara #2
-Rhoda Esther (also known as Hadassah)
-Abijah Esther (also known as Hadassah)
-Naamah #2 Ezrah
-Abijah Ezrah
-Peninnah Vaniah
-Chelub Vaniah
-Rahab Helek
-Shillem Helek
-Jehoaddan (or Jehoaddin) Sharar
-Molid Sharar
-Elisabeth Abinadab
-Elpaal Abinadab
-Elisabeth Gemalli
-Enan #1 Gemalli
-Meshullemeth Jemima #2
-Guni Jemima #2
-Lo-Ruhamah Tamar #3
-Hallohesh Tamar #3
-Rahab Abihail #1
-Naboth Abihail #1
-Rahab Amos
-Chenaniah Amos
-Hushim #2 Hashabnah
-Joezer Hashabnah
-Ephah Adbeel
-Ishijah Adbeel
-Keziah Igdaliah
-Jathniel Igdaliah
-Rahab Mahlah #1
-Ahisamach Mahlah #1
-Jehoaddan (or Jehoaddin) Malcam
-Chelub Malcam
-Merab Jachin
-Shemer Jachin
-Merab Uel
-Aduel Uel
-Baara #2 Jekoliah
-Jehoaddah Jekoliah
-Rhoda Jakeh
-Ithream Jakeh
-Jehoaddan (or Jehoaddin) Zohar
-Ithream Zohar
-Rachel Ard
-Ithream Ard
-Jemima #2 Sheerah
-Jathniel Sheerah
-Zeresh Dorcas, also known as Tabitha. Acts[46]
-Ozni Dorcas, also known as Tabitha. Acts[46]
-Jehoaddan (or Jehoaddin) Elizaphan
-Shuthelah Elizaphan
-Jecholiah Ir
-Shelemiah Ir
-Rachel Hananiah
-Adbeel Hananiah
-Hushim #2 Ishod
-Shemer Ishod
-Jecholiah Heber
-Maaziah Heber
-Keziah Sabtah
-Elpaal Sabtah
-Zeresh Obadiah
-Josiphiah Obadiah
-Rahab Hogla (or Hoglah)
-Josiphiah Hogla (or Hoglah)
-Ephah Mallothi
-Josiphiah Mallothi
-Jemima #2 Nekoda
-Sethur Nekoda
-Ephah Haahashtari
-Elpalet Haahashtari
-Baara #2 Hubbah
-Ithai Hubbah
-Naamah #2 Caleb, son of Hezron
-Adbeel Caleb, son of Hezron
-Rhoda Zuar
-Maaziah Zuar
-Jemima #2 Rizpah
-Hashabnah Rizpah
-Abihail #1 Joel
-Jehoshaphat Joel
-Jecholiah Jacan
-Joezer Jacan
-Jehoaddan (or Jehoaddin) Libni
-Jathniel Libni
-Jehoaddan (or Jehoaddin) Anani
-Helek Anani
-Hushim #2 Naphtuhim
-Abinadab Naphtuhim
-Jehoaddan (or Jehoaddin) Zillah #2
-Vaniah Zillah #2
-Abihail #1 Habazziniah
-Elpaal Habazziniah
-Rahab Achsah (or Acsah)
-Elnaam Achsah (or Acsah)
-Jemima #2 Ishui
-Vaizatha Ishui
-Baara #2 Sapphira
-Ishod Sapphira
-Abihail #1 Judas of Straight Street in Damascus
-Ishod Judas of Straight Street in Damascus
-Tamar #3 Shabbethai
-Ithai Shabbethai
-Mahlah #1 Jehoiada
-Shemer Jehoiada
-Achsah (or Acsah) Obil
-Hananiah Obil
-Zillah #2 Hemam
-Zuar Hemam
-Esther (also known as Hadassah) Pedahel
-Caleb, son of Hezron Pedahel
-Achsah (or Acsah) Pedahzur
-Uel Pedahzur
-Achsah (or Acsah) Baanah
-Hashabnah Baanah
-Sheerah Jehdeiah
-Hananiah Jehdeiah
-Jemima #2 Iru
-Jachin Iru
-Hogla (or Hoglah) Shelomit #2
-Raphu Shelomit #2
-Baara #2 Parmashta
-Vaizatha Parmashta
-Abihail #1 Nereus
-Shemer Nereus
-Esther (also known as Hadassah) Jasiel
-Joel Jasiel
-Merab Shaaph
-Sabtah Shaaph
-Abihail #1 Genubath
-Gemalli Genubath
-Mahlah #1 Ben Deker
-Sabtah Ben Deker
-Baara #2 Euodia
-Chelluh Euodia
-Jemima #2 Kolaiah
-Zohar Kolaiah
-Jecholiah Sered
-Amos Sered
-Baara #2 Arodi
-Helek Arodi
-Sheerah Zabad
-Haahashtari Zabad
-Rachel Birsha
-Haahashtari Birsha
-Jemima #2 Uriah ben Shemaiah
-Ard Uriah ben Shemaiah
-Rizpah Helah
-Obadiah Helah
-Abihail #1 Abigail #3
-Ishod Abigail #3
-Hogla (or Hoglah) Ishuah
-Chelluh Ishuah
-Sapphira Nebuzaradan
-Ard Nebuzaradan
-Shelomit #2 Jamin
-Obadiah Jamin
-Sapphira Lael
-Jekoliah Lael
-Shelomit #2 Jeatherai
-Shaaph Jeatherai
-Shelomit #2 Nehum
-Iru Nehum
-Hogla (or Hoglah) Keturah
-Genubath Keturah
-Achsah (or Acsah) On
-Shabbethai On
-Rizpah Matthanias
-Ir Matthanias
-Abigail #3 Ahilud
-Anani Ahilud
-Sheerah Lydia of Thyatira
-Arodi Lydia of Thyatira
-Dorcas, also known as Tabitha. Acts[46] Nedabiah
-Shaaph Nedabiah
-Dorcas, also known as Tabitha. Acts[46] Jalon
-Zuar Jalon
-Euodia Zephaniah
-Pedahel Zephaniah
-Hogla (or Hoglah) Miamin
-Genubath Miamin
-Sapphira Ahlai #2
-Genubath Ahlai #2
-Zillah #2 Jael
-Obadiah Jael
-Sapphira Miniamin
-Jehdeiah Miniamin
-Sapphira Urijah
-Heber Urijah
-Rizpah Jahmai
-Zabad Jahmai
-Hogla (or Hoglah) Delaiah
-Joel Delaiah
-Shelomit #2 Salome #1
-Mallothi Salome #1
-Rizpah Mibsam
-Jasiel Mibsam
-Dorcas, also known as Tabitha. Acts[46] Antiochus
-Ishod Antiochus
-Rizpah Harnepher
-Genubath Harnepher
-Hogla (or Hoglah) Jishui
-Jasiel Jishui
-Shelomit #2 Mehujael
-Pedahel Mehujael
-Sapphira Hagar
-Habazziniah Hagar
-Sheerah Obal
-Jekoliah Obal
-Sapphira Aggaba
-Birsha Aggaba
-Hogla (or Hoglah) Hathach
-Sabtah Hathach
-Helah Elzaphan
-Ishod Elzaphan
-Helah Bidkar
-Nereus Bidkar
-Ahlai #2 Mezahab
-Jahmai Mezahab
-Lydia of Thyatira Abimael
-Jamin Abimael
-Hagar Harbona
-Ben Deker Harbona
-Jael Jonathan son of Kareah
-Matthanias Jonathan son of Kareah
-Shelomit #2 Elpelet
-Pedahel Elpelet
-Euodia Hezron
-Baanah Hezron
-Hagar Chuza
-Hemam Chuza
-Antiochus Mary #2
-On Mary #2
-Keturah Geber
-Sered Geber
-Keturah Tamar #1
-Delaiah Tamar #1
-Antiochus Arah
-Mehujael Arah
-Sapphira Ahiram
-Ahilud Ahiram
-Abigail #3 Ozem
-Hemam Ozem
-Helah Joiarib
-Delaiah Joiarib
-Shelomit #2 Rohgah
-Bidkar Rohgah
-Salome #1 Jozabad
-Birsha Jozabad
-Helah Mithredath
-Jeatherai Mithredath
-Jael Elionenai
-Nebuzaradan Elionenai
-Keturah Putiel
-Hemam Putiel
-Abigail #3 Amzi
-Nebuzaradan Amzi
-Ahlai #2 Matthan
-Jasiel Matthan
-Shelomit #2 Malchiah
-Ben Deker Malchiah
-Abigail #3 Elidad
-Jamin Elidad
-Keturah Haggith
-Harnepher Haggith
-Abigail #3 Becher
-Delaiah Becher
-Euodia Ahinadab
-Mibsam Ahinadab
-Antiochus Ishhod
-On Ishhod
-Lydia of Thyatira Jeriah
-Harnepher Jeriah
-Hagar Rehabiah
-Elidad Rehabiah
-Tamar #1 Ahian
-Arah Ahian
-Mary #2 Jerioth
-Elidad Jerioth
-Ahlai #2 Amaziah
-Jozabad Amaziah
-Lydia of Thyatira Phaltiel
-Chuza Phaltiel
-Haggith Nahath
-Harnepher Nahath
-Lydia of Thyatira Jecholiah (or Jecoliah)
-Joiarib Jecholiah (or Jecoliah)
-Hagar Ahinoam #1
-Nebuzaradan Ahinoam #1
-Haggith Jaaziel
-Ishhod Jaaziel
-Jael Shobal
-Amzi Shobal
-Keturah Enoch
-Mithredath Enoch
-Tamar #1 Shaashgaz
-Geber Shaashgaz
-Lydia of Thyatira Linus
-Lael Linus
-Lydia of Thyatira Mahazioth
-Abimael Mahazioth
-Ahlai #2 Rekem
-Rohgah Rekem
-Lydia of Thyatira Athlai
-Mehujael Athlai
-Lydia of Thyatira Keren-happuch
-On Keren-happuch
-Salome #1 Jeremai
-Elionenai Jeremai
-Tamar #1 Izrahiah
-Mithredath Izrahiah
-Tamar #1 Asenath
-Elpelet Asenath
-Ahlai #2 Jehudi
-Nedabiah Jehudi
-Haggith Rinnah
-Nedabiah Rinnah
-Lydia of Thyatira Ithmah
-Ahilud Ithmah
-Salome #1 Amasiah
-Ahinadab Amasiah
-Mary #2 Eldaah
-Elpelet Eldaah
-Tamar #1 Eliadah
-Izrahiah Eliadah
-Jecholiah (or Jecoliah) Zithri
-Rehabiah Zithri
-Asenath Hareph
-Geber Hareph
-Jerioth Taphath #2
-Izrahiah Taphath #2
-Haggith Pelaliah
-Jeriah Pelaliah
-Jerioth Ephrath
-Becher Ephrath
-Ahinoam #1 Jediael
-Becher Jediael
-Mary #2 Me-Zahab
-Elpelet Me-Zahab
-Asenath Puah
-Shobal Puah
-Jecholiah (or Jecoliah) Basemeth #2
-Abimael Basemeth #2
-Jerioth Allon
-Abimael Allon
-Ahinoam #1 Maai
-Keren-happuch Maai
-Haggith Parnach
-Elidad Parnach
-Mary #2 Jehush
-Jeriah Jehush
-Haggith Simon Iscariot
-Izrahiah Simon Iscariot
-Asenath Jaanai
-Rekem Jaanai
-Mary #2 Ahimoth
-Geber Ahimoth
-Ephrath Ishuai
-Phaltiel Ishuai
-Jerioth Anna the Prophetess
-Mahazioth Anna the Prophetess
-Puah Aziel
-Phaltiel Aziel
-Basemeth #2 Laish
-Nahath Laish
-Jerioth Nehushta
-Jaaziel Nehushta
-Jecholiah (or Jecoliah) Josibiah
-Eliadah Josibiah
-Jecholiah (or Jecoliah) Jerioth #2
-Rekem Jerioth #2
-Taphath #2 Malchi-shua
-Jaaziel Malchi-shua
-Ephrath Shobab
-Izrahiah Shobab
-Me-Zahab Diblaim
-Amasiah Diblaim
-Ahinoam #1 Enan #2
-Izrahiah Enan #2
-Ephrath Hori
-Jehudi Hori
-Asenath Martha
-Athlai Martha
-Ephrath Machnadebai
-Izrahiah Machnadebai
-Jerioth Carmi
-Linus Carmi
-Jecholiah (or Jecoliah) Jahzeel
-Keren-happuch Jahzeel
-Ahinoam #1 Sachar
-Ahian Sachar
-Asenath Zeri
-Jehush Zeri
-Basemeth #2 Mishmannah
-Jediael Mishmannah
-Me-Zahab Abdi
-Maai Abdi
-Puah Jeshohaiah
-Enoch Jeshohaiah
-Basemeth #2 Aholibamah (or Oholibamah)
-Shaashgaz Aholibamah (or Oholibamah)
-Jerioth Eran
-Eldaah Eran
-Taphath #2 Ribai
-Hareph Ribai
-Me-Zahab Pildash
-Hori Pildash
-Martha Ramiah
-Josibiah Ramiah
-Martha Mnason
-Abdi Mnason
-Aholibamah (or Oholibamah) Keren–Happuch
-Maai Keren–Happuch
-Taphath #2 Chimham
-Shobab Chimham
-Puah Meraioth
-Eran Meraioth
-Nehushta Hamul
-Jehush Hamul
-Ephrath Abida
-Enan #2 Abida
-Basemeth #2 Elisheba
-Ahimoth Elisheba
-Nehushta Meshelemiah
-Jehush Meshelemiah
-Aholibamah (or Oholibamah) Magpiash
-Ribai Magpiash
-Jerioth #2 Gilalai
-Jediael Gilalai
-Nehushta Machbanai
-Mishmannah Machbanai
-Anna the Prophetess Mahlah #2
-Jahzeel Mahlah #2
-Martha Jimnah
-Allon Jimnah
-Nehushta Ibneiah
-Eliadah Ibneiah
-Nehushta Gamul
-Machbanai Gamul
-Keren–Happuch Jonathan son of Abiathar
-Josibiah Jonathan son of Abiathar
-Mahlah #2 Akkub
-Shobab Akkub
-Nehushta Zidkijah
-Abdi Zidkijah
-Diblaim Gamaliel
-Meshelemiah Gamaliel
-Elisheba Naphish
-Jeshohaiah Naphish
-Nehushta Sarah #2
-Abdi Sarah #2
-Nehushta Iscah #2
-Shobab Iscah #2
-Nehushta Nahbi
-Ramiah Nahbi
-Nehushta Jahzerah
-Ibneiah Jahzerah
-Elisheba Raddai
-Magpiash Raddai
-Diblaim Admatha
-Jimnah Admatha
-Nehushta Neariah
-Josibiah Neariah
-Nehushta Basemath
-Zeri Basemath
-Mahlah #2 Jesimiel
-Ibneiah Jesimiel
-Anna the Prophetess Elizur
-Sachar Elizur
-Elisheba Mary #4
-Jeshohaiah Mary #4
-Diblaim Elisheba #2
-Malchi-shua Elisheba #2
-Elisheba Jogli
-Carmi Jogli
-Anna the Prophetess Elishaphat
-Pildash Elishaphat
-Mahlah #2 Shechem
-Meraioth Shechem
-Keren–Happuch Melech
-Hamul Melech
-Aholibamah (or Oholibamah) Job
-Mishmannah Job
-Keren–Happuch Romamti-ezer
-Abida Romamti-ezer
-Martha Jekamiah
-Machbanai Jekamiah
-Mahlah #2 Jecamiah
-Sachar Jecamiah
-Elisheba Vophsi
-Mnason Vophsi
-Anna the Prophetess Jareb
-Enan #2 Jareb
-Jerioth #2 Abital
-Abdi Abital
-Anna the Prophetess Ehi
-Machnadebai Ehi
-Mary #4 Jarib
-Jahzerah Jarib
-Basemath Ziphah
-Meraioth Ziphah
-Iscah #2 Jakim
-Machbanai Jakim
-Basemath Peulthai
-Romamti-ezer Peulthai
-Sarah #2 Joanna
-Jonathan son of Abiathar Joanna
-Sarah #2 Jehiel
-Gilalai Jehiel
-Mahlah #2 Hodesh
-Hamul Hodesh
-Iscah #2 Regem-melech
-Hamul Regem-melech
-Mary #4 Eglah #2
-Gamul Eglah #2
-Mahlah #2 Huldah
-Neariah Huldah
-Abital Anak
-Jekamiah Anak
-Mary #4 Shimshai
-Neariah Shimshai
-Abital Huzzab
-Jareb Huzzab
-Sarah #2 Ginath
-Ibneiah Ginath
-Elisheba Antothijah
-Jimnah Antothijah
-Elisheba #2 Mary #1
-Jesimiel Mary #1
-Abital Syntyche
-Romamti-ezer Syntyche
-Iscah #2 Maadai
-Meshelemiah Maadai
-Elisheba Jerijah
-Shechem Jerijah
-Abital Hakkoz
-Jimnah Hakkoz
-Elisheba #2 Orpah
-Meraioth Orpah
-Elisheba #2 Mehetabel #2
-Romamti-ezer Mehetabel #2
-Mahlah #2 Chenaanah
-Abida Chenaanah
-Keren–Happuch Deborah #1
-Job Deborah #1
-Keren–Happuch Zipporah
-Jimnah Zipporah
-Mary #4 Jeuel
-Chimham Jeuel
-Keren–Happuch Eglah
-Raddai Eglah
-Iscah #2 Amon
-Melech Amon
-Abital Matred
-Job Matred
-Keren–Happuch Iphdeiah
-Mnason Iphdeiah
-Orpah Hobab
-Jecamiah Hobab
-Deborah #1 Hamutal
-Jerijah Hamutal
-Deborah #1 Hod
-Jahzerah Hod
-Huldah Joshua the governor of the city
-Neariah Joshua the governor of the city
-Eglah #2 Karshena
-Gamaliel Karshena
-Abital Jaasiel
-Jehiel Jaasiel
-Mary #1 Parshandatha
-Jecamiah Parshandatha
-Eglah #2 Naaman
-Romamti-ezer Naaman
-Mehetabel #2 Jerah
-Akkub Jerah
-Zipporah Candace
-Jakim Candace
-Eglah #2 Marsena
-Nahbi Marsena
-Basemath Beriah
-Antothijah Beriah
-Basemath Haran
-Elizur Haran
-Hodesh Gemariah
-Vophsi Gemariah
-Mary #1 Gatam
-Neariah Gatam
-Deborah #1 Junia or Junias
-Jonathan son of Abiathar Junia or Junias
-Mary #1 Shelumiel
-Shechem Shelumiel
-Mary #4 Moab
-Regem-melech Moab
-Iscah #2 Idbash
-Neariah Idbash
-Matred Shelomith
-Neariah Shelomith
-Abital Mattatha
-Ziphah Mattatha
-Abital Abitub
-Jonathan son of Abiathar Abitub
-Joanna Piram
-Antothijah Piram
-Mary #1 Medium of En Dor
-Jogli Medium of En Dor
-Mary #1 Zillah
-Jesimiel Zillah
-Huldah Ahasbai
-Gamaliel Ahasbai
-Orpah Asareel
-Piram Asareel
-Matred Claudia #2
-Naaman Claudia #2
-Syntyche Atarah
-Mattatha Atarah
-Medium of En Dor Hashabiah
-Gatam Hashabiah
-Zillah Haggi
-Hakkoz Haggi
-Junia or Junias Laadah
-Moab Laadah
-Zillah Mary #5
-Marsena Mary #5
-Orpah Ephron
-Antothijah Ephron
-Eglah #2 Beno
-Ginath Beno
-Syntyche Miriam #2
-Jakim Miriam #2
-Deborah #1 Keziah #2
-Joshua the governor of the city Keziah #2
-Mehetabel #2 Shinab
-Jehiel Shinab
-Medium of En Dor Gera
-Parshandatha Gera
-Junia or Junias Adnah
-Jakim Adnah
-Junia or Junias Jezebel
-Karshena Jezebel
-Shelomith Bathsheba
-Haran Bathsheba
-Deborah #1 Gazez
-Haran Gazez
-Zillah Ahishahar
-Amon Ahishahar
-Eglah Paseah
-Regem-melech Paseah
-Orpah Stachys
-Marsena Stachys
-Joanna Izhar
-Abitub Izhar
-Hodesh Maacah
-Ginath Maacah
-Hamutal Abigail #4
-Regem-melech Abigail #4
-Hamutal Shemeber
-Joshua the governor of the city Shemeber
-Hodesh Ahiezer
-Chenaanah Ahiezer
-Miriam #2 Michaiah
-Ahishahar Michaiah
-Hamutal Janai
-Parshandatha Janai
-Hamutal Sheshan
-Asareel Sheshan
-Medium of En Dor Hamor
-Beriah Hamor
-Candace Ezbon
-Idbash Ezbon
-Claudia #2 Shiphtan
-Marsena Shiphtan
-Mary #5 Palti
-Idbash Palti
-Atarah Mibhar
-Hobab Mibhar
-Miriam #2 Tryphosa
-Joshua the governor of the city Tryphosa
-Atarah Maacah #2
-Naaman Maacah #2
-Claudia #2 Matred #2
-Ahishahar Matred #2
-Zillah Melchi
-Gera Melchi
-Atarah Johanan son of Kareah
-Jerah Johanan son of Kareah
-Medium of En Dor Eliada
-Ahishahar Eliada
-Abigail #4 Hotham
-Jaasiel Hotham
-Maacah Machi
-Haggi Machi
-Bathsheba Ibsam
-Hashabiah Ibsam
-Mary #5 Melzar
-Haran Melzar
-Mary #5 Zebadiah
-Gatam Zebadiah
-Candace Azaliah
-Shemeber Azaliah
-Keziah #2 Ahzai
-Gazez Ahzai
-Zillah Lahmi
-Piram Lahmi
-Maacah Bukki
-Izhar Bukki
-Junia or Junias Arnan
-Asareel Arnan
-Abigail #4 Zichri
-Izhar Zichri
-Hamutal Kelita
-Laadah Kelita
-Medium of En Dor Evi
-Jerah Evi
-Medium of En Dor Naomi
-Joshua the governor of the city Naomi
-Mary #5 Aiah
-Naaman Aiah
-Claudia #2 Hoham
-Gazez Hoham
-Jezebel Appaim
-Moab Appaim
-Keziah #2 Ethni
-Gazez Ethni
-Junia or Junias Hashubah
-Asareel Hashubah
-Zillah Persian 'مهمان signifies a stranger or guest' [17] Melatiah
-Paseah Persian 'مهمان signifies a stranger or guest' [17] Melatiah
-Bathsheba Hodesh #2
-Ahishahar Hodesh #2
-Naomi Susi
-Gera Susi
-Bathsheba Pagiel
-Lahmi Pagiel
-Claudia #2 Gomer
-Tryphosa Gomer
-Claudia #2 Merib-baal
-Ephron Merib-baal
-Miriam #2 Adah # 1
-Tryphosa Adah # 1
-Claudia #2 Phurah
-Zebadiah Phurah
-Keziah #2 Claudia
-Kelita Claudia
-Abigail #4 Ben Abinadab
-Shemeber Ben Abinadab
-Claudia #2 Joash
-Ezbon Joash
-Matred #2 Meraiah
-Ahzai Meraiah
-Maacah #2 Pethuel
-Bukki Pethuel
-Miriam #2 Hephziba
-Ahishahar Hephziba
-Bathsheba Naarah
-Michaiah Naarah
-Matred #2 Rehum
-Persian 'مهمان signifies a stranger or guest' [17] Melatiah Rehum
-Claudia #2 Minjamin
-Hoham Minjamin
-Bathsheba Ittai
-Shiphtan Ittai
-Atarah Ashbel
-Hamor Ashbel
-Claudia #2 Reumah
-Mibhar Reumah
-Matred #2 Jeshishai
-Ethni Jeshishai
-Atarah Ibnijah
-Tryphosa Ibnijah
-Claudia #2 Jaasau
-Azaliah Jaasau
-Matred #2 Merab #2
-Ibsam Merab #2
-Atarah Shedeur
-Melzar Shedeur
-Matred #2 Jezer
-Lahmi Jezer
-Maacah Baara
-Palti Baara
-Jezebel Kemuel
-Aiah Kemuel
-Mary #5 Immer
-Shiphtan Immer
-Atarah Pethahiah
-Aiah Pethahiah
-Miriam #2 Zedekiah
-Azaliah Zedekiah
-Maacah Hammolekheth
-Melzar Hammolekheth
-Matred #2 Jarha
-Shiphtan Jarha
-Mary #5 Dalphon
-Gera Dalphon
-Bathsheba Maon
-Appaim Maon
-Merab #2 Hepher
-Machi Hepher
-Claudia Jemuel
-Melchi Jemuel
-Reumah Hon
-Ibsam Hon
-Reumah Zippor
-Shiphtan Zippor
-Merab #2 Tyrannus
-Kemuel Tyrannus
-Merab #2 Eunice
-Kelita Eunice
-Adah # 1 Shaharaim
-Jezer Shaharaim
-Hammolekheth Hasrah
-Maon Hasrah
-Matred #2 Jochebed
-Minjamin Jochebed
-Hodesh #2 Gideoni
-Tryphosa Gideoni
-Naarah Zabud
-Sheshan Zabud
-Naarah Regem
-Meraiah Regem
-Hephziba Zeror
-Zichri Zeror
-Maacah #2 Shimi
-Ittai Shimi
-Merab #2 Miriam #1
-Minjamin Miriam #1
-Merab #2 Ishvah
-Melzar Ishvah
-Reumah Henadad
-Kemuel Henadad
-Merab #2 Hasupha
-Ibnijah Hasupha
-Matred #2 Seled
-Joash Seled
-Maacah #2 Jozachar
-Ben Abinadab Jozachar
-Claudia Azubah #1
-Kemuel Azubah #1
-Hammolekheth Hachmoni
-Ezbon Hachmoni
-Hodesh #2 Ziphion
-Mibhar Ziphion
-Hephziba Jidlaph
-Lahmi Jidlaph
-Baara Meshillemoth
-Pethuel Meshillemoth
-Claudia Athaliah
-Jezer Athaliah
-Claudia Jerusha
-Ittai Jerusha
-Baara Raamiah
-Azaliah Raamiah
-Gomer Ethnan
-Maon Ethnan
-Hephziba Mahol
-Jaasau Mahol
-Merab #2 Hathath
-Ishvah Hathath
-Merab #2 Gishpa
-Ittai Gishpa
-Baara Barzillai
-Gideoni Barzillai
-Azubah #1 Reba
-Ibnijah Reba
-Athaliah Jedidah
-Ittai Jedidah
-Jerusha Ahitub
-Phurah Ahitub
-Miriam #1 Shisha
-Susi Shisha
-Athaliah Jeezer
-Shaharaim Jeezer
-Hodesh #2 Jehubbah
-Maon Jehubbah
-Adah # 1 Jehozabad
-Kemuel Jehozabad
-Claudia Reumah #2
-Hon Reumah #2
-Eunice Jeshaiah
-Ishvah Jeshaiah
-Claudia Phoebe
-Ittai Phoebe
-Hephziba Ahlai #1
-Minjamin Ahlai #1
-Hammolekheth Ikkesh
-Hon Ikkesh
-Reumah Alexander
-Pethuel Alexander
-Azubah #1 Ben Hesed
-Kemuel Ben Hesed
-Merab #2 Q
-Immer Q
-Azubah #1 Shelomi
-Kemuel Shelomi
-Hephziba Rephael
-Jozachar Rephael
-Azubah #1 Jahleel
-Kemuel Jahleel
-Claudia Mahalath #1
-Ittai Mahalath #1
-Hodesh #2 Igal
-Zippor Igal
-Gomer Ophir
-Ethnan Ophir
-Miriam #1 Jehudijah
-Pethuel Jehudijah
-Gomer Ebed-melech
-Ethnan Ebed-melech
-Phoebe Zeruiah
-Ophir Zeruiah
-Jedidah Jaaziah
-Zabud Jaaziah
-Eunice Jahaziah
-Regem Jahaziah
-Miriam #1 Bela
-Jahleel Bela
-Eunice Zerah
-Jeezer Zerah
-Miriam #1 Phuvah
-Ebed-melech Phuvah
-Miriam #1 Poratha
-Rephael Poratha
-Jerusha Julia #2
-Zeror Julia #2
-Reumah #2 Elishama
-Hasupha Elishama
-Eunice Rakem
-Gishpa Rakem
-Athaliah Priscilla
-Zippor Priscilla
-Jedidah Mary #6
-Ishvah Mary #6
-Jerusha Admin
-Hepher Admin
-Jerusha Nephish
-Jozachar Nephish
-Jedidah Mishael
-Jidlaph Mishael
-Jedidah Izziah
-Q Izziah
-Jochebed Mijamin
-Ethnan Mijamin
-Mahalath #1 Elead
-Jehozabad Elead
-Jehudijah Mahali
-Tyrannus Mahali
-Reumah #2 Chelal
-Shaharaim Chelal
-Reumah #2 Abdeel
-Raamiah Abdeel
-Mahalath #1 Nebat
-Henadad Nebat
-Ahlai #1 Azubah #2
-Ahitub Azubah #2
-Mahalath #1 Harum
-Shaharaim Harum
-Ahlai #1 Matthat
-Hepher Matthat
-Ahlai #1 Susanna #2
-Ziphion Susanna #2
-Miriam #1 Michal
-Jehubbah Michal
-Mahalath #1 Elimelech
-Ebed-melech Elimelech
-Jedidah Deuel
-Igal Deuel
-Ahlai #1 Hajehudijah
-Ziphion Hajehudijah
-Eunice Hiel
-Zippor Hiel
-Mahalath #1 Muppim
-Jeezer Muppim
-Julia #2 Ebed
-Ben Hesed Ebed
-Ahlai #1 Sarsekim
-Phuvah Sarsekim
-Mary #6 Joahaz
-Shisha Joahaz
-Phoebe Abiel
-Jeezer Abiel
-Azubah #2 Athaiah
-Q Athaiah
-Azubah #2 Ahlai
-Nebat Ahlai
-Ahlai #1 Hiram
-Gishpa Hiram
-Susanna #2 Ben-Ammi
-Elimelech Ben-Ammi
-Susanna #2 Julia
-Rephael Julia
-Julia #2 Michri
-Hiel Michri
-Priscilla Areli
-Mahali Areli
-Jehudijah Shelomit #1
-Elead Shelomit #1
-Julia #2 Assir
-Rakem Assir
-Priscilla Ajah
-Ikkesh Ajah
-Zeruiah Peleth
-Ikkesh Peleth
-Mary #6 Gaddi
-Ebed-melech Gaddi
-Zeruiah Aedias
-Poratha Aedias
-Azubah #2 Elihoreph
-Admin Elihoreph
-Phoebe Seba
-Rephael Seba
-Susanna #2 Phalti
-Shisha Phalti
-Julia #2 Lo-Ammi
-Elead Lo-Ammi
-Jedidah Izri
-Mahol Izri
-Azubah #2 Joshibiah
-Jahaziah Joshibiah
-Susanna #2 Irijah
-Rakem Irijah
-Susanna #2 Jamlech
-Izziah Jamlech
-Jedidah Susanna #1
-Ophir Susanna #1
-Reumah #2 Rabmag
-Mijamin Rabmag
-Priscilla Dishan
-Mijamin Dishan
-Julia #2 Ahi
-Elimelech Ahi
-Susanna #2 Naharai
-Muppim Naharai
-Mary #6 Semachiah
-Admin Semachiah
-Azubah #2 Jehizkiah
-Q Jehizkiah
-Priscilla Milcah #1
-Bela Milcah #1
-Ahlai #1 Elioenai
-Igal Elioenai
-Julia Naamah #1
-Aedias Naamah #1
-Julia #2 Bilhah
-Harum Bilhah
-Mary #6 Joseph
-Poratha Joseph
-Julia #2 Eshek
-Rakem Eshek
-Zeruiah Ephod
-Zerah Ephod
-Susanna #2 Jibsam
-Jehizkiah Jibsam
-Michal Hazelelponi (or Hazzelelponi)
-Ahi Hazelelponi (or Hazzelelponi)
-Mary #6 Zaavan
-Lo-Ammi Zaavan
-Priscilla Helkai
-Jamlech Helkai
-Julia Hanoch
-Harum Hanoch
-Shelomit #1 Hanniel
-Mahali Hanniel
-Zeruiah Hammoleketh
-Elioenai Hammoleketh
-Milcah #1 Aharhel
-Bela Aharhel
-Azubah #2 Ishmerai
-Chelal Ishmerai
-Zeruiah Mahath
-Izziah Mahath
-Shelomit #1 Matri
-Hiram Matri
-Milcah #1 Eliathah
-Mijamin Eliathah
-Julia #2 Imna
-Hiram Imna
-Susanna #2 Shammua
-Ben-Ammi Shammua
-Azubah #2 Ahuzzam
-Irijah Ahuzzam
-Susanna #2 Rephaiah
-Mishael Rephaiah
-Michal Shemaiah
-Elioenai Shemaiah
-Susanna #2 Basemeth #1
-Bela Basemeth #1
-Zeruiah Carshena
-Elishama Carshena
-Azubah #2 Hezekiah
-Poratha Hezekiah
-Julia Salu
-Ajah Salu
-Michal Jehoaddan
-Dishan Jehoaddan
-Susanna #1 Sheconiah
-Izri Sheconiah
-Azubah #2 Diklah
-Hajehudijah Diklah
-Milcah #1 Isshiah
-Abdeel Isshiah
-Susanna #1 Ephlal
-Mahali Ephlal
-Susanna #2 Shimeah
-Hajehudijah Shimeah
-Azubah #2 Eve
-Elishama Eve
-Susanna #2 Queen Vashti
-Sarsekim Queen Vashti
-Susanna #1 Adlai
-Naharai Adlai
-Susanna #2 Joshbekashah
-Harum Joshbekashah
-Shelomit #1 Maaseiah
-Salu Maaseiah
-Hazelelponi (or Hazzelelponi) Barkos
-Assir Barkos
-Milcah #1 Anaiah
-Zaavan Anaiah
-Julia Pinon
-Dishan Pinon
-Hazelelponi (or Hazzelelponi) Jekuthiel
-Joahaz Jekuthiel
-Bilhah Azzan
-Hanoch Azzan
-Eve Asiel
-Gaddi Asiel
-Milcah #1 Japhia
-Aharhel Japhia
-Susanna #1 Mahlah
-Hammoleketh Mahlah
-Naamah #1 Ahinoam #2
-Mahath Ahinoam #2
-Milcah #1 Joshaviah
-Hammoleketh Joshaviah
-Queen Vashti Harim
-Diklah Harim
-Susanna #1 Tirzah
-Rephaiah Tirzah
-Basemeth #1 Homam
-Ephlal Homam
-Susanna #1 Mash
-Carshena Mash
-Eve Jezebel #1
-Eshek Jezebel #1
-Bilhah Maasiai
-Ahuzzam Maasiai
-Susanna #1 Harhaiah
-Mahath Harhaiah
-Julia Lois, grandmother of Saint Timothy. II Timothy[101]
-Assir Lois, grandmother of Saint Timothy. II Timothy[101]
-Bilhah Pul
-Ben-Ammi Pul
-Shelomit #1 Gideon
-Aedias Gideon
-Milcah #1 Milcah #2
-Ishmerai Milcah #2
-Ahinoam #2 Ishmaiah
-Japhia Ishmaiah
-Naamah #1 Elnathan
-Carshena Elnathan
-Bilhah Maher-shalal-hash-baz
-Shammua Maher-shalal-hash-baz
-Milcah #2 Shemuel
-Anaiah Shemuel
-Basemeth #1 Abdon
-Maasiai Abdon
-Hazelelponi (or Hazzelelponi) Ruth
-Harhaiah Ruth
-Milcah #2 Azariah
-Hammoleketh Azariah
-Jezebel #1 Jezrahiah
-Adlai Jezrahiah
-Jehoaddan Shephatiah
-Helkai Shephatiah
-Milcah #2 Barachel
-Ephod Barachel
-Jehoaddan Saph
-Maaseiah Saph
-Lois, grandmother of Saint Timothy. II Timothy[101] Dodavahu
-Shammua Dodavahu
-Bilhah Rezon
-Shimeah Rezon
-Jehoaddan Shearjashub
-Barkos Shearjashub
-Queen Vashti Tamar #2
-Matri Tamar #2
-Queen Vashti Taphath
-Ahuzzam Taphath
-Jezebel #1 Alvan
-Jibsam Alvan
-Eve Zabdi
-Eliathah Zabdi
-Tirzah Darda
-Asiel Darda
-Queen Vashti Iram
-Maasiai Iram
-Tirzah Ben Hur
-Adlai Ben Hur
-Lois, grandmother of Saint Timothy. II Timothy[101] Hazaiah
-Hanniel Hazaiah
-Basemeth #1 Elzabad
-Isshiah Elzabad
-Milcah #2 Malchiel
-Salu Malchiel
-Milcah #2 Joed
-Zaavan Joed
-Jehoaddan Ahishar
-Joshaviah Ahishar
-Basemeth #1 Harhas
-Mahath Harhas
-Milcah #2 Phallu
-Aharhel Phallu
-Ahinoam #2 Shemida
-Harhaiah Shemida
-Eve Azaniah
-Carshena Azaniah
-Bilhah Jehosheba (or Jehoshebeath/Josaba)
-Hanniel Jehosheba (or Jehoshebeath/Josaba)
-Jehoaddan Haddad
-Anaiah Haddad
-Tirzah Hammelech
-Anaiah Hammelech
-Queen Vashti Jehallelel
-Helkai Jehallelel
-Eve Harumaph
-Mash Harumaph
-Queen Vashti Jaareshiah
-Harhaiah Jaareshiah
-Lois, grandmother of Saint Timothy. II Timothy[101] Milalai
-Joshbekashah Milalai
-Jehosheba (or Jehoshebeath/Josaba) Hanameel
-Malchiel Hanameel
-Jezebel #1 Hodaviah
-Maher-shalal-hash-baz Hodaviah
-Taphath Ahuzzath
-Iram Ahuzzath
-Jezebel #1 Jeziah
-Joed Jeziah
-Mahlah Paltiel
-Phallu Paltiel
-Jehosheba (or Jehoshebeath/Josaba) Adah #2
-Pul Adah #2
-Jezebel #1 Elasah
-Maaseiah Elasah
-Tamar #2 Naum
-Joed Naum
-Ahinoam #2 Iri
-Hazaiah Iri
-Tirzah Imri
-Hammelech Imri
-Taphath Ammizabad
-Jekuthiel Ammizabad
-Lois, grandmother of Saint Timothy. II Timothy[101] Naggai
-Jekuthiel Naggai
-Taphath Jobab
-Barkos Jobab
-Jezebel #1 Elon
-Elzabad Elon
-Milcah #2 Jesui
-Shearjashub Jesui
-Jezebel #1 Shaphat
-Jaareshiah Shaphat
-Tamar #2 Jezebel #2
-Ishmaiah Jezebel #2
-Taphath Rosh
-Pinon Rosh
-Jezebel #1 Michael
-Azariah Michael
-Lois, grandmother of Saint Timothy. II Timothy[101] Meshullam
-Abdon Meshullam
-Ahinoam #2 Tola
-Rezon Tola
-Jezebel #1 Hazo
-Milalai Hazo
-Tamar #2 Ishpah
-Jaareshiah Ishpah
-Taphath Jarah
-Ben Hur Jarah
-Mahlah Abihail #2
-Zabdi Abihail #2
-Jezebel #1 Imla
-Malchiel Imla
-Mahlah Timnah (or Timna)
-Anaiah Timnah (or Timna)
-Tirzah Kelal
-Homam Kelal
-Jezebel #1 Jokim
-Shearjashub Jokim
-Ahinoam #2 Ishiah
-Mash Ishiah
-Ruth Leah
-Shephatiah Leah
-Timnah (or Timna) Methushael
-Joed Methushael
-Leah Massa
-Naum Massa
-Jehosheba (or Jehoshebeath/Josaba) Jesher
-Hazaiah Jesher
-Leah Mushi
-Iri Mushi
-Abihail #2 Jahzeiah
-Harumaph Jahzeiah
-Jehosheba (or Jehoshebeath/Josaba) Geuel
-Maher-shalal-hash-baz Geuel
-Taphath Jushab-hesed
-Jarah Jushab-hesed
-Ruth Joelah
-Paltiel Joelah
-Ruth Anah
-Kelal Anah
-Ruth Hakkatan
-Rosh Hakkatan
-Jezebel #2 Zuriel
-Shearjashub Zuriel
-Tamar #2 Hodiah's wife
-Elzabad Hodiah's wife
-Jezebel #2 Shimron
-Dodavahu Shimron
-Jezebel #2 Hadadezer
-Dodavahu Hadadezer
-Taphath Noadiah
-Meshullam Noadiah
-Timnah (or Timna) Jaasu
-Milalai Jaasu
-Jehosheba (or Jehoshebeath/Josaba) Zaccur
-Michael Zaccur
-Taphath Malluch
-Rosh Malluch
-Jezebel #2 Jeush
-Abdon Jeush
-Jehosheba (or Jehoshebeath/Josaba) Basemeth #3
-Elzabad Basemeth #3
-Abihail #2 Eleasah
-Jaareshiah Eleasah
-Tamar #2 Uri
-Ahuzzath Uri
-Jezebel #2 Dodo
-Darda Dodo
-Abihail #2 Pelatiah
-Jezrahiah Pelatiah
-Jezebel #2 Joshah
-Maher-shalal-hash-baz Joshah
-Timnah (or Timna) Adna
-Shemida Adna
-Tamar #2 Mehetabeel
-Imla Mehetabeel
-Leah Eri
-Darda Eri
-Leah Mehuman
-Zabdi Mehuman
-Ruth Narcissus
-Ishpah Narcissus
-Taphath Isui
-Jehallelel Isui
-Leah Deborah #2
-Jarah Deborah #2
-Basemeth #3 Zurishaddai
-Zaccur Zurishaddai
-Jezebel #2 Sachia
-Malluch Sachia
-Timnah (or Timna) Eluzai
-Michael Eluzai
-Adah #2 Bithiah
-Ishiah Bithiah
-Mehetabeel Anan
-Joelah Anan
-Deborah #2 Tahan
-Isui Tahan
-Deborah #2 Ishbah
-Jesher Ishbah
-Timnah (or Timna) Iscah
-Jobab Iscah
-Leah Eliphal
-Imla Eliphal
-Deborah #2 Meres
-Eri Meres
-Deborah #2 Dinah
-Jesui Dinah
-Jezebel #2 Hermogenes
-Jaasu Hermogenes
-Basemeth #3 Cozbi
-Jeush Cozbi
-Deborah #2 Sodi
-Elasah Sodi
-Noadiah Lo–Ruhamah
-Ishiah Lo–Ruhamah
-Leah Ziza
-Uri Ziza
-Hodiah's wife Machbena
-Massa Machbena
-Adah #2 Habaiah
-Mehuman Habaiah
-Hodiah's wife Meremoth
-Geuel Meremoth
-Mehetabeel Jaasai
-Eleasah Jaasai
-Anah Heldai
-Jokim Heldai
-Hodiah's wife Hoshama
-Ishiah Hoshama
-Basemeth #3 Shiphrah
-Shaphat Shiphrah
-Leah Nepheg
-Ahuzzath Nepheg
-Deborah #2 Hagab
-Rosh Hagab
-Anah Zilpah
-Methushael Zilpah
-Timnah (or Timna) Shammah
-Iri Shammah
-Basemeth #3 Jehiah
-Malluch Jehiah
-Jezebel #2 Eubulus
-Jaasu Eubulus
-Anah Amminadib
-Meshullam Amminadib
-Basemeth #3 Adalia
-Hadadezer Adalia
-Hodiah's wife Dibri
-Elon Dibri
-Zilpah Chislon
-Dibri Chislon
-Noadiah Shagee
-Malluch Shagee
-Mehetabeel Abiasaph
-Heldai Abiasaph
-Anah Zalmon
-Jahzeiah Zalmon
-Mehetabeel Isshijah
-Narcissus Isshijah
-Hodiah's wife Adina
-Eubulus Adina
-Deborah #2 Ismaiah
-Zurishaddai Ismaiah
-Noadiah Agee
-Isui Agee
-Mehetabeel Sabtechah
-Machbena Sabtechah
-Basemeth #3 Hushim
-Jaasai Hushim
-Basemeth #3 Nobah
-Shammah Nobah
-Deborah #2 Elienai
-Zurishaddai Elienai
-Iscah Chalcol
-Heldai Chalcol
-Basemeth #3 Hannah
-Anan Hannah
-Noadiah Damaris. Acts[41]
-Hoshama Damaris. Acts[41]
-Noadiah Pelaiah
-Geuel Pelaiah
-Lo–Ruhamah Irad
-Ziza Irad
-Basemeth #3 Salome #2
-Ziza Salome #2
-Dinah Ahab
-Nepheg Ahab
-Hodiah's wife Jaziz
-Jeush Jaziz
-Anah Mahalath
-Isui Mahalath
-Zilpah Abishag
-Zuriel Abishag
diff --git a/hw/hw2/starter-code/DATA/person.facts b/hw/hw2/starter-code/DATA/person.facts
deleted file mode 100644
index 3131bf54784effc6362d467c717b8472a096436f..0000000000000000000000000000000000000000
--- a/hw/hw2/starter-code/DATA/person.facts
+++ /dev/null
@@ -1,852 +0,0 @@
-Persian 'مهمان signifies a stranger or guest' [17] Melatiah Melatiah the Gibeonite is a person who, according to Nehemiah 3:7, was responsible for rebuilding a portion of the wall of Jerusalem after the end of the Babylonian captivity.
-Ethnan Ethnan, the son of Ashur the father of Tekoa, is a figure who appears in a genealogy of the Tribe of Judah in 1 Chronicles 4:7. He may be included in the genealogy to represent Ithnan, a Judahite city mentioned in Joshua 15:23.[120]
-Ibneiah Ibneiah is the name given in Chronicles to a leader of a clan in the Tribe of Benjamin which returned to Yehud Medinata after the Babylonian captivity.[194] The same character is referred to as 'Gabbai' in the parallel passage in Nehemiah.[195][196]
-Iphdeiah Iphdeiah (KJV Iphediah) is a name which appears very briefly as that of 'Iphdeiah son of Shashak,' mentioned only in a genealogy of the Tribe of Asher according to Chronicles.[208][209]
-Bidkar Bidkar (Hebrew: בדקר) was an officer of the Israelite king Jehu. Jehu ordered Bidkar to throw the body of the king he usurped, Jehoram, into the field of Naboth, fulfilling prophecy. II Kings 9:25
-Elioenai Elioenai is the name of several minor persons found in the Hebrew Bible. An Elioenai appears in 1 Chronicles 3:23-24: the son of Neariah, the son of Shemaiah, the son of Shecaniah, a descendant of king Jeconiah. A clan leader in the Tribe of Simeon, according to 1 Chronicles 4:36. Elioenai son of Becher, a descendant of the Tribe of Benjamin according 1 Chronicles 7:8. A descendant of Pashhur, one of the priests listed as having married foreign women (Ezra 10:22). A descendant of Zattu, also listed with those who had foreign wives (Ezra 10:27). A priest involved in the dedication of the wall of Jerusalem according to Nehemiah 12:41. This may be the same as the descendant of Passhur (above).[106] Elioenai or Elihoenai, son of Meshelemiah, son of Korah (1 Chronicles 26:3).
-Leah First wife of Jacob who was given to him in place of Rachel whom he loved. Genesis, Ruth[99][100]
-Ishhod Ishhod (King James Version Ishod) is a figure mentioned only once in the Hebrew Bible.[216] 1 Chronicles 7:18 lists Ishod as a son of Hammoleketh in a genealogy of the Tribe of Manasseh.
-Hashubah Hashubah is listed as one of the children of Zerubabel, the governor of Yehud Medinata.[167]
-Joshbekashah Joshbekashah appears as one of the sons of Heman in a passage which describes the musicians of the Jerusalem Temple in the time of David.[304]
-Ebed-melech Ebed-melech (Hebrew: עבד-מלך eved-melekh 'slave of the king'), the Ethiopian eunuch, intervened with king Zedekiah on behalf of Jeremiah (Jeremiah 38:7ff)
-Milalai 'Eloquent', a Levitical musician (Neh 12:36) who took part in the dedication of the wall of Jerusalem.
-Malcam For the deity sometimes called Malcam, Malcham, or Milcom, see Moloch. Malcam (King James Version spelling Malcham) son of Shaharaim appears only once in the Hebrew Bible in a genealogy of the Tribe of Benjamin.[9][10]
-Maon According to 1 Chronicles 2:45, Maon was a member of the clan of Caleb, the son of Shammai and the father of Beth Zur.
-Ehi In Genesis 46:21, Ehi is the third son of Benjamin. In 1 Chronicles 8:1 he is called Aharah, and in Numbers 26:38 he is called Ahiram.
-Ishui See Ishvi.
-Jimnah Jimnah or Jimna was a son of Asher according to Genesis 46:17 and Numbers 26:44. He was one of the 70 souls to migrate to Egypt with Jacob.
-Mahlah #2 I Chronicles[61]
-Mahlah #1 one of the daughters of Zelophehad Numbers, Joshua[71][108]
-Bechorath Bechorath, son of Aphiah, of the tribe of Benjamin, was an ancestor of King Saul and of his commander Abner. According to Saul, his family was the least of the tribe of Benjamin. (1 Samuel 9)
-Jaareshiah Jaareshiah (KJV Jaresiah) is a name which appears only 1 Chronicles 8:27, where Jaaresiah is identified as one of the sons of Jeroham.[236] The text does not identify any information about Jeroham's parentage, but the passage is part of a genealogy of the Tribe of Benjamin.[236]
-Raamiah Raamiah (Hebrew רַעַמְיָה 'thunder of the Lord') is one of the princes who returned from the Exile (Neh. 7:7). He is also called Reelaiah in Ezra 2:2.
-Dalphon Dalphon (Hebrew דַּלְפוֹן 'to weep') was one of the ten sons of Haman, killed along with Haman by the Jews of Persia, according to Esther 9:7.
-Abital one of King David's wives II Samuel; I Chronicles[6][7]
-Milcah #2 one of the daughters of Zelophehad. Numbers, Joshua[71][108]
-Milcah #1 wife of Nahor and daughter of Haran. Genesis[75][134]
-Ethni See Ethni.
-Elzaphan Elzaphan was a son of Uzziel of the house of Levi according to Exodus 6:22, born in Egypt. He was a nephew of Amram and a cousin of Aaron, Miriam, and Moses. He and Mishael were asked by Moses to carry away Nadab's and Abihu's bodies to a place outside the camp. (Leviticus 10:4). In the wilderness of Sinai he was named chief of the house of Kohath (Numbers 3:30).
-Muppim Muppim (Hebrew ×žÖ»×¤Ö´Ö¼×™× 'wave offerings') or Shuphim was the eighth son of Benjamin in Genesis 46:21 and Numbers 26:39.
-Jehudijah Jehudijah (Hebrew hayyehudiyyah) is, in the King James Version, the name of a wife of Mered, and the mother of several of his children.[276] The Jewish Publication Society Bible of 1917 calls her 'Hajehudijah.' However, the Revised Version simply treats the word as a noun: 'the Jewess.'[276] The meaning of the passage is difficult due to several scribal errors.[276]
-Hiel Hiel the Bethelite (Heb. ×Ö²×—Ö´×™×ֵל, ×—Ö´×™×ֵל; 'the [divine] brother, or kinsman, is God')[182]) rebuilt Jericho during the reign of King Ahab. (I Kings 16:34)
-Elpaal Elpaal is a name mentioned briefly in 1 Chronicles 8, in a genealogy of the Tribe of Benjamin.[112] He is recorded as the son of a woman named Hushim, the wife of a man named Shaharaim. The relationship between Shaharaim and Benjamin is not spelled out by the Chronicler. Elpaal is recorded as the father of people who included the builders or ancestors of the towns of Ono, Lod, and Ajalon.
-Matred Matred, according to Genesis 36:39 and 1 Chronicles 1:50, was the mother-in-law of the Edomite king Hadad II.[11]
-Ishiah See Jesiah.
-Jerusha Jerusha (or Jerushah) the daughter of Zadok was, according to the Hebrew Bible, the mother of king Jotham of Judah.[287]
-Adlai Adlai is in Hebrew עַדְלָי, meaning 'refuge'. In 1 Chronicles 27:29, he is the father of Shaphat, and the grandfather of the prophet Elisha. He is mentioned only in this verse.
-Dibri Dibri, a Danite, was the father of Shelomith, according to Leviticus 24:11. Shelomith's son was stoned to death by the people of Israel for blasphemy following Moses' issue of a ruling[94] on the penalty to be applied for blasphemy.
-Ophir Ophir was a son of Joktan according to Genesis 10:29, 1 Chronicles 1:23.
-Igdaliah Igdaliah (Hebrew yigdalyahu) is mentioned in passing as the father of a man named Hanan in Jeremiah 35:3. According to the Book of Jeremiah, the sons or descendants of Hanan son of Igdaliah had their own chamber in the temple at Jerusalem, which was the site of the famous object-lesson concerning Jeremiah and the Rechabites.[201] The Encyclopaedia Biblica claimed that the name Igdaliah was most likely a mistaken form of the name Gedaliah.[202]
-Josiphiah Josiphiah is a name which appears in a list of returnees from the Babylonian captivity, where 'Shelomith son of Josiphiah' is listed as the leader of the 160 men of the 'descendants of Bani' who returned to Yehud Medinata in the time of Nehemiah.[306]
-Jarha Jarha was an Egyptian slave of Sheshan who was married to Sheshan's daughter according to 1 Chronicles 2:34-35.
-Appaim Appaim is a minor figure who appears in 1 Chronicles 2:30 and 31. He appears briefly in a genealogy of Jerahmeelites, in which he is the father Ishi, son of Appaim, son of Nadab, son of Shammai, son of Onam, son of Jerahmeel. In manuscripts of the Septuagint, he is called Ephraim, Aphphaim, or Opheim.[60]
-Ahimoth Ahimoth appears in 1 Chronicles 6:25 (verse 10 in some Bibles). It is the name given for one of the descendants of Kehath the son of Levi.
-Ishuah See Ishvah.
-Adbeel Adbeel (Hebrew ×ַדְבְּ×ֵל 'disciplined by God') Nadbeel or Idiba’ilu, was the third son of Ishmael out of twelve. (Genesis 25:13) The name Adbeel is associated with the personal name and northwest tribe in Arabia known as Idiba’ilu, whom Tiglath-Pileser conquered in the 8th century BCE. (Kenneth A. Mathews, 2005, p. 361)[clarification needed]
-Noah daughter of Zelophehad. Numbers[145]
-Hammolekheth possibly rules over portion of Gilead. I Chronicles[61]
-Athaliah Queen of Judah during the reign of King Jehoram, and later became sole ruler of Judah for five years. II Kings, II Chronicles[24][25]
-Achsah (or Acsah) daughter of Caleb. When Caleb promised her to Othniel in marriage, she requested that he increased her dowry to include not only land, but springs of water as well. Joshua, Judges, I Chronicles[8][9][10]
-Adalia Mentioned only in Esther 9:8, Adalia is the fifth of the Persian noble Haman's ten sons.[28] Adalia was slain along with his nine siblings in Susa. In various manuscripts of the Septuagint, his name is given as Barsa, Barel, or Barea.[28]
-Hajehudijah See Jehudijah.
-Shuthelah Shuthelah was a son of Ephraim according to Numbers 26:35 and 1 Chronicles 7:20.
-Harumaph Harumaph is listed as the father of Jedaiah, a man responsible for making repairs to a part of Nehemiah's wall. He is only mentioned once in the Bible, in Nehemiah 3:10.[158]
-Jehizkiah Jehizkiah son of Shallum is mentioned in a list of Ephraimite leaders who, according to 2 Chronicles 28, intervened along with the prophet Oded to prevent the enslavement of 200,000 people from the Kingdom of Judah during the time of the king Ahaz.[270]
-Ahinadab Ahinadab (Hebrew: ××—×™× ×“×‘ Ahinadav 'my brother Is noble' or 'my brother has devoted himself'),[41] son of Iddo, is one of the twelve commissariat officers appointed by Solomon to districts of his kingdom to raise supplies by monthly rotation for his household. He was appointed to the district of Mahanaim (1 Kings 4:14), east of Jordan.
-Queen Vashti wife of King Ahasuerus. Esther[156]
-Hoham Hoham, according to the Book of Joshua, was the king of Hebron, defeated in Joshua's conquest.[189]
-Amasiah In 2 Chronicles 17:16, Amasiah (meaning burden of Jehovah) was the son of Zichri, a captain under King Jehoshaphat.
-Amminadib A person mentioned in the Old Testament in Song of Solomon 6:12, whose chariots were famed for their swiftness. It is rendered in the margin 'my willing people,' and in the Revised Version 'my princely people.'
-Ahasbai Ahasbai, the son of the Maachathite, was the father of Eliphelet, one of King David's Warriors (2 Samuel 23:34).
-Jehallelel Jehallelel (KJV Jehaleleel or Jehalelel) is the name of two individuals in the Hebrew Bible.[266] A Jehallelel appears in 1 Chronicles 4:16, in a genealogy of the Tribe of Judah. Another Jehallelel appears in a list of Levites in 2 Chronicles 29:12.
-Jokim Jokim is listed as one of the descendants of Shelah, son of Judah (son of Jacob) in 1 Chronicles 4:22.
-Deuel Deuel (Hebrew דְּעוּ×ֵל) was the father of Eliasaph the leader of the Tribe of Gad, as noted in four verses in the Book of Numbers: Numbers 1:14; 7:42,47; 10:20. However, in Numbers 2:14 this Eliasaph is called 'the son of Reuel.'
-Hammelech Hammelech, in the King James Version is the name of the father of Jerahmeel (Jeremiah 36:26), and it is the name of the father of Malkijah (Jeremiah 38:6). In a number of more recent translations, the Hebrew ha-melekh is taken as the common noun 'the king' instead of the proper noun 'Hammelech.'[147]
-Eubulus Eubulus was an associate of Paul the Apostle who greeted Saint Timothy in 2 Timothy 4:21.
-Helon Helon was a member of the house of Zebulun according to Numbers 1:9. He was the father of Eliab.
-Ahiezer Ahiezer the son of Ammishaddai was the leader of the tribe of Dan and one of the leaders of the tribes of Israel mentioned in several places in the Book of Numbers.
-Semachiah Semachiah (or Semakiah) is the name of a figure who appears in 1 Chronicles 26:7, in a genealogical passage concerning gatekeepers of the Jerusalem Temple. Semachiah is described as a son of Shemaiah, a son of Obed-Edom.
-Igal Igal is the name of three biblical figures. Igal son of Joseph of the house of Issachar, a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:7. Igal son of Nathan of Zobah is mentioned only in 2 Samuel 23:36 in a list of David's Mighty Warriors. Igal son of Shemaiah is listed as a descendant of Zerubbabel in 1 Chronicles 3:22. This last figure is called Igeal in the King James Version, although his name in Hebrew is the same as the other two Igals.[200]
-Gideon Gideon was the son of Joash the Abiezrite, according to Judges 6:11. He defeated the Midianites.
-Machbanai Hebrew for 'Clad with a mantle, or bond of the Lord', one of the Gadite heroes who joined David in the wilderness 1 Chronicles 12:13
-Ithmah Ithmah is a name which appears only once in the Hebrew Bible, in 1 Chronicles 11:46, where 'Ithmah the Moabite' is listed as one of David's Mighty Warriors.[226]
-Mahalath #1 daughter of Ishmael and 3rd wife of Esau. Genesis[106]
-Deborah #2 Prophetess and the fourth, and the only female, Judge of pre–monarchic Israel in the Old Testament. Judges[43]
-Meshullemeth 'Friend', the wife of King Manasseh of Judah, and the mother of King Amon of Judah (2 Kings 21:19).
-Pul Pul was an abbreviation for the Assyrian king Tiglath-Pileser III. Pul attacked Israel in the reign of Menahem and extracted tribute. II Kings 15:19
-Rinnah Rinnah appears once in the Bible, as the son of a man named Shimon (1 Chronicles 4:20) in a genealogy of Tribe of Judah. Neither Shimon's origin nor precise relationship to Judah is given.
-Shillem Shillem was a son of Naphtali according to Genesis 46:24 and Numbers 26:49. He was one of the 70 souls to migrate to Egypt with Jacob.
-Abishag concubine of aged King David. I Kings[5]
-Jeriel Jeriel, son of Tola, son of Issachar, is found in a genealogy of the Tribe of Issachar in 1 Chronicles 7:2.
-Naharai Naharai (or Nahari) the Beerothite is listed in 2 Samuel 23:37 and 1 Chronicles 11:39 as one of David's Mighty Warriors.[23]
-Zedekiah (Hebrew צִדְקִיָּה tsidqiyah 'the LORD is righteous and just')[51] Zedekiah, King of Judah Zedekiah, son of Chenaanah, a false prophet in the time of Kings Jehoshaphat and Ahab[52] Zedekiah, son of Maaseiah, who, according to Jeremiah 29:21, was a false prophet.[53] Zedekiah the son of Hananiah, one of the princes to whom Michaiah told of Jeremiah's prophecy - Jeremiah 36:12
-Kelal Kelal or Chelal is a person listed in Ezra as among those who married foreign women.[32]
-Meshillemoth Meshillemoth (in one case spelled Meshillemith) is the name of two figures in the Hebrew Bible.[18] The father of Berechiah, a member of the Tribe of Ephraim during the time when Pekah was king.[19] A priest, the son of Immer.[20] He is called 'Meshillemoth' in 1 Chronicles 9:12.[18]
-Jeiel Jeiel is the name of ten individuals in the Hebrew Bible.[277] Jeiel, according to 1 Chronicles 5:7, was a leader in the Tribe of Reuben. Jeiel, referred to as the 'father of Gibeon', was an ancestor of King Saul.[278] The King James Version calls him 'Jehiel.'[277] This figure's name is affected by variant readings preserved through the Qere and Ketiv system in the Masoretic Text: the Ketiv calls him 'Jeuel,' while the Qere calls him 'Jeiel.'[277] Jeiel son of Hotham the Aroerite is listed as one of David's warriors in 1 Chronicles 11:44. The King James Version calls him 'Jehiel.' This figure's name is affected by variant readings preserved through the Qere and Ketiv system in the Masoretic Text: the Ketiv calls him 'Jeuel,' while the Qere calls him 'Jeiel.'[277] A Jeiel is mentioned in passing in a list of gatekeepers for the Ark of the Covenant in 1 Chronicles 15:18. A Jeiel is listed as one of the ancestors of a Levite named Jahaziel in 2 Chronicles 20:14. A Jeiel was one of the scribes of Uzziah according to 2 Chronicles 26:11. This figure's name is affected by variant readings preserved through the Qere and Ketiv system in the Masoretic Text: the Ketiv calls him 'Jeuel,' while the Qere calls him 'Jeiel.'[277] A Jeiel is recorded as a Levite in the time of Hezekiah. This figure's name is affected by variant readings preserved through the Qere and Ketiv system in the Masoretic Text: the Ketiv calls him 'Jeuel,' while the Qere calls him 'Jeiel.'[277] The Revised Version calls him Jeuel, following the Ketiv.[277] A Jeiel is recorded as a leader in the Tribe of Levi in time of Uzziah according to 2 Chronicles 35:9. In a list of returnees to Yehud Medinata after the end of the Babylonian captivity, a Jeiel is recorded as being the head of a group of relatives according to Ezra 8:13. The Revised Version calls him Jeuel. A Jeiel, of the 'descendants of Nebo,' is listed as one of the people opposing marriage to foreign women in the time of Nehemiah.[279]
-Alvah In Genesis 36:40, Alvah is a chief of Edom and a descendant of Esau. In 1 Chronicles 1:51 he is called Aliah.
-Aiah Aiah (××™×” 'Falcon') was the father of Rizpah, mentioned in 2 Samuel 3:7
-Jidlaph Jidlaph was the son of Nahor and Milcah (Genesis 22:22).
-Jehudi Jehudi (Hebrew יהודי 'Judahite') 'the son of Nethaniah, the son of Shelemiah, the son of Cushi' (Jeremiah 36:14) was one of the delegates the princes sent to fetch Baruch, Jeremiah's scribe, to read his scroll.
-Ithran Ithran is the name given for two figures in the Hebrew Bible.[227] Ithran, son of Dishon, son of Anah, son of Zibeon, son of Seir the Horite.[228] This Ithran represents the name of a Horite clan.[227] Ithran, son of Zophah, son of Helem appears in a genealogy of the Tribe of Asher.[229] The Encyclopaedia Biblica identifies the 'Jether' of 1 Chronicles 7:38 as probably being identical to this Ithran.[227]
-Jaanai See Janai (biblical figure).
-Timnah (or Timna) concubine of Eliphaz and mother of Amalek. Genesis[192]
-Amon Amon (Hebrew: ×מן 'aMoN) was a city governor in the time of Kings Jehoshaphat and Ahab[50]
-Isui See Ishvi.
-Haddad Haddad the Edomite was an adversary of Solomon (I Kings 10:14).
-Imla Imla (Hebrew - ימל×, 'whom God will fill up' [203]), the father of Micaiah, which latter was the prophet who ironically foretold the defeat of the allied kings of Judah and Israel against Ramoth-gilead (2 Chron 18:7-8). In the parallel passage (1 Kings 22:8-9) his name is written Imlah.
-Ocran Ocran was a member of the house of Asher according to Numbers 1:13. He was the father of Pagiel.
-Ribai Ribai, a Benjamite of Gibeah, was the father of Ittai, one of King David's Warriors (2 Samuel 23:29, 1 Chronicles 11:31).
-Simon Iscariot Simon Iscariot was the father of Judas Iscariot (see John 6:71, John 13:2, and John 13:26).
-Habazziniah Habazziniah or Habaziniah was either the head of a family of Rechabites (Jeremiah 35:3), or else a place name for the location that a Rechabite lived.[136] According to Cheyne and Black, it may have been a scribal error where the name 'Kabzeel,' a place in the territory of Judah, was originally intended.'[136]
-Hashabnah Hashabnah is the name given for one of the men who signed the covenant between the people of Judah and God in Nehemiah 10:25 (verse 26 in some Bibles). According to Cheyne and Black, the name is likely a miswritten form of 'Hashabniah.'[165]
-Elimelech Elimelech was the husband of Naomi. Together they had two sons, Mahlon and Chilion. He was originally a resident of Bethlehem before moving to Moab with his family, where he died (see Ruth 1:1-3). All of his property was later purchased by Boaz (see Ruth 4:9).
-Amos The 10th generation grandfather of Jesus through Joseph, according to Luke 3:25.
-Zillah #2 wife of Lamech and the mother of Tubal-cain and Naamah. Genesis[196]
-Becher Becher was the name of two individuals mentioned in the Bible: The second of ten sons of Benjamin according to Genesis 46:21 and 1 Chronicles 7:6 A son of Ephraim according to Numbers 26:35. His descendants were referred to as Bachrites.
-Shemeber Shemeber is the king of Zeboiim in Genesis 14 who joins other Canaanite city kings in rebelling against Chedorlaomer.
-Hathach Hathach or Hatach is the name of one of the eunuchs of Ahasuerus in the Book of Esther. He acts as an messenger between Esther and Mordecai.[168]
-Eran Eran was a son of Shuthelah of the Tribe of Ephraim according to Numbers 26:36.
-Ahi (Hebrew ×Ö²×—Ö´×™ 'brother/kindred of YHWH') Ahi is the son of Abdiel in 1 Chronicles 5:15 Ahi is the son of Shomer in 1 Chronicles 7:34
-Gaddiel Gaddiel, the son of Sodi of the house of Zebulun, was a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:10.
-Elisabeth Mother of John the Baptist and the wife of Zacharias. Luke[48]
-Zephon See Ziphion.
-Lois, grandmother of Saint Timothy. II Timothy[101]
-Naphtuhim Naphtuhim is a son of Mizraim and grandson of Ham first mentioned in Genesis 10:13.
-Aholibamah (or Oholibamah) Daughter of Anah and one of Esau's wives. Also called Judith. Genesis[19]
-Anani Anani is a name which appears in a genealogy in Chronicles.[55] It refers to a descendant of Zerubbabel. According to the Masoretic Text Anani was born six generations after Zerubbabel. For scholars, this six-generation span after Zerubbabel is the terminus a quo for the date of Chronicles—it implies that Chronicles could not have been written earlier than about 400 BCE.[56] In the Septuagint, Anani is listed as eleven generations removed from Zerubbabel. For scholars who believe that the Septuagint reading for Anani's genealogy is correct, this places the earliest possible date for the writing of Chronicles at about 300 BCE.[56]
-Naomi mother–in–law to Ruth. Ruth[144]
-Eglah Eglah was one of David's wives and the mother of Ithream, according to II Samuel 3:4.
-Jehiah Jehiah is a figure who is only mentioned once in the Bible, in 1 Chronicles 15:24, which describes him as a gatekeeper for the Ark of the Covenant in the time of David.[268]
-Jareb Jareb is a name which appears in Hosea 5:13 and 10:16 in some translations of the Bible.[257] In both passages, the Hebrew text refers to a mlk yrb (KJV 'King Jareb') in a way that implies that mlk yrb is the king of Assyria.[258] However, no Assyrian king by the name of 'Jareb' is known to history, which has led to a variety of conjectures about what the phrase refers to.[259] According to W. F. Albright, the 'definitive solution' to the problem is that the text should read mlk rb or mlky rb, meaning 'the great king', a Hebrew translation of the common Assyrian royal title sharru rabu.[258] The proposed emendation to 'great king' has been accepted in a number of biblical translations.[260]
-Aggaba For the Aggaba of 1 Esdras 5:29, see Hagabah.
-Gilalai Gilalai is the name of a priest who participated as a musician in a procession lead by Ezra.[128][129]
-Abigail #4 wife of the wicked Nabal, who became a wife of David after Nabal's death. I Samuel[2]
-Narcissus Narcissus is mentioned briefly in Romans 16:11, which sends greetings to 'Those of the household of Narcissus who are in the Lord.'[27] Beyond this brief reference, nothing more is known for certain of the person referred to.[27]
-Obal Obal, also Ebal, was a son of Joktan according to Genesis 10:28, 1 Chronicles 1:22.
-Abigail #3 mother of Amasa, Sister of David. I Chronicles[1]
-Shammah See Shammah for several figures by this name.
-Jeshohaiah Jeshohaiah appears in a list of names of Simeonites. According to Chronicles these Simeonites took pasture-land from descendants of Ham and the Meunim during the time of king Hezekiah.[290] According to Thomas Kelly Cheyne, the name is a corruption of Maaseiah.[291]
-Jeuel Jeuel son of Zerah appears in a list of people living in Jerusalem after the end of the Babylonian exile. For four other individuals who are sometimes called 'Jeuel' and sometimes 'Jeiel,' see Jeiel.
-Haggith Wife of King David, mother of Adoniyah II Samuel, I Kings, I Chronicles[58][59][60]
-Rhoda Acts[168]
-Lo-Ruhamah Lo-Ruhamah (Hebrew for 'not loved') was the daughter of Hosea and Gomer. She had an older brother named Jezreel and a younger brother named Lo-Ammi. Her name was chosen by God to symbolize his displeasure with the people of Israel (see Hosea 1:1-9).
-Dishan Dishan (Hebrew דִּיש×וֹן dishon) was the youngest son of Seir the Horite. (Genesis 36:21)
-Mehuman Faithful, one of the eunuchs whom Ahasuerus commanded to bring in Vashti (Esther 1:10).
-Hashub Hashub is mentioned in passing as the father of Shemaiah, a Levite who is listed among those living in Jerusalem after the end of the Babylonian captivity.[166]
-Zilpah Leah's handmaid who becomes a wife of Jacob and bears him two sons Gad and Asher. Genesis[197]
-Jehosheba (or Jehoshebeath/Josaba) Daughter of Jehoram and wife of Jehoiada. She saved her nephew Jehoash from massacre. II Kings[82]
-Jemima Jemima, meaning 'Dove' was a daughter of Job according to Job 42:14.
-Azaniah Azaniah is mentioned in passing in Nehemiah 10:9 (10 in some Bibles) as the name the father of Levite who signed the covenant of Nehemiah. The name means 'Yahweh listened.'[75]
-Jehush See Jeush.
-Harhaiah Harhaiah, in the Masoretic Text of Nehemiah 3:8, is mentioned in passing, as being the father of Uzziel, a man responsible for the repair of part of the wall of Jerusalem. The awkward phrasing of the verse suggested to Stanley A. Cook (1899) that there had been some scribal mishandling of the verse, and that the verse originally did not contain the name 'Harhaiah.'[154]
-Jahleel Jahleel was a son of Zebulun according to Genesis 46:14 and Numbers 26:26. He was one of the 70 persons to migrate to Egypt with Jacob.
-Helah I Chronicles[66]
-Shemida Shemida was a son of Manasseh according to Numbers 26:32, Joshua 17:2, and 1 Chronicles 7:19.
-Evi Evi was one of five Midianite kings killed during the time of Moses by an Israelite expedition led by Phinehas, son of Eleazar according to Numbers 31:8 and Joshua 13:21.
-Maasiai Hebrew for 'Worker of Jehovah', one of the priests resident at Jerusalem at the Captivity 1 Chronicles 9:12
-Maacah 2nd wife of King Rehoboam. Mother of Abijah, Attai, Ziza and Shelomith. Rehoboam loved Maacah more than any other of his wives or concubines. 'II Chronicles'[104]
-Elidad Elidad was a prince of the tribe of Benjamin; one of those appointed by Moses to superintend the division of Canaan amongst the tribe (Numbers 34: 21).
-Phallu Phallu or Pallu was a son of Reuben according to Genesis 46:9, Exodus 6:14 and Numbers 26:5. He was one of the 70 souls to migrate to Egypt with Jacob.
-Asenath Egyptian wife of Joseph Genesis[22]
-Jerusha #2 Daughter of Zadok, a priest, wife of King Uzziah and mother of Jotham. II Kings, I Chronicles, II Chronicles[85][86]
-Rephael In 1 Chronicles 26:7–8, Rephael (Hebrew: רְפָ×ֵל, Modern Refaʾel, Tiberian RÉ™pÌ„Äʾēl; 'healed of God') was one of Shemaiah's sons. He and his brethren, on account of their 'strength for service,' formed one of the divisions of the temple porters.
-Eve First woman, wife of Adam. Genesis[55]
-Libni Libni (Hebrew ×œÖ´×‘Ö°× Ö´×™ 'whiten, purify, make bricks') was a son of Gershon of the house of Levi according to Exodus 6:17 and Numbers 3:18. He was born in Egypt. His descendants are referred to as the 'Libnites'.[1]
-Abdi The name Abdi (Hebrew עַבְדִּי) is probably an abbreviation of Obediah, meaning 'servant of YHWH', according to the International Standard Bible Encyclopedia.[4] Easton's Bible Encyclopedia, on the other hand, holds that it means 'my servant'. The name 'Abdi' appears three times in forms of the Bible that are in use among Jews, Protestants, and Roman Catholics. There is also one additional appearance in 1 Esdras, considered canonical in Eastern Orthodox Churches. 1 Chronicles 6:29.[5] 'And on the left hand their brethren the sons of Merari: Ethan the son of Kishi, the son of Abdi, the son of Malluch.'[6] 2 Chronicles 29:12. 'Then the Levites arose, Mahath the son of Amasai, and Joel the son of Azariah, of the sons of the Kohathites; and of the sons of Merari, Kish the son of Abdi, and Azariah the son of Jehallelel; and of the Gershonites, Joah the son of Zimmah, and Eden the son of Joah.'[6] Ezra 10:26. 'And of the sons of Elam: Mattaniah, Zechariah, and Jehiel, and Abdi, and Jeremoth, and Elijah.'[6] 1 Esdras 9:27, where the name appears in the Hellenized form Oabd[e]ios.[7] 'Of the sons of Elam: Matthanias and Zacharias and Iezrielos and Obadios and Ieremoth and Elias.'[8] According to Cheyne and Black (1899), the two mentions in the Books of Chronicles are of a single individual, and the mentions in Ezra and 1 Esdras are of a second individual.[9]
-Zillah In Genesis 4:19,22-23 Zillah is a wife of Lamech and the mother of Tubal-cain and Naamah.
-Hasadiah Hasadiah is listed as one of the sons of Zerubabel in 1 Chronicles 3:20, and is therefore a member of the royal lineage of the Judahite kings.
-Ziphion Ziphion or Zephon is a son of Gad (Genesis 46:16), and was the progenitor of the Zephonites (Numbers 26:15). There may be a connection with the angel Zephon.
-Rabmag Rabmag (Hebrew רַב־מָג) is the name of two figures in the Bible: The Assyrian 'Rab-mugi' — a 'chief physician' who was attached to the king of Babylon (Jeremiah 39:3,13). The title of one of Sennacherib's officers sent with messages to Hezekiah and the people of Jerusalem demanding the surrender of the city. He was accompanied by a 'great army;' but his mission was unsuccessful (II Kings 18:17-19:13 and Isaiah 36:12-37:13).
-Magpiash Magpiash, according to Nehemiah 10:20, was one of the men who signed a covenant between God and the people of Yehud Medinata.
-Shimeah The name Shimeah is used for two figures in the Hebrew Bible. Shimeah or Shammah was a third son of Jesse, a brother of David (1 Samuel 16:9}, and the father of Jonadab (2 Samuel 13:3). A figure named Mikloth is the father of Shimeah according to 1 Chronicles 8:32, which gives no further information about either of them but places them in a genealogy of the Tribe of Benjamin. In a parallel passage, 1 Chronicles 9:38 calls this son of Mikloth Shimeam, and presents Mikloth as a son of 'Jehiel the father of Gibeon,' making Mikloth a great-uncle of the Israelite king Saul.
-Ephlal Ephlal is the name given to a Jerahmeelite found a genealogy in 1 Chronicles.[116] He is identified as the son of Zabad, the son of Nathan, the son of Attai, the son of Jarha, the son-in-law of Sheshan, the son of Ishi, the son of Appaim, the son of Nadab, the son of Shammai, the son of Onam, the son of Jerahmeel. In various manuscripts of the Greek Septuagint, the name is found in the forms Aphamel, Aphamed, and Ophlad. Stanley Arthur Cook (1899) suggested that the name might originally have been either an abbreviated form of Eliphelet, or else the name 'Elpaal.'[117]
-Malchiah Malchiah (Hebrew: מלכיהו malkiyahu 'God is my king') son of the king (Jeremiah 38:6), owner of the pit into which Jeremiah was thrown
-Hagab Hagab (also Agaba, Accaba) is identified as the ancestor of a family of Nethinim, or temple assistants, who returned from the Babylonian exile.[140] They appear in a list with other returnees in Ezra 2:46, but are omitted in the corresponding place in Nehemiah 7:48. A Hellenized version of this name appears in a similar context in 1 Esdras 5:30.[140] In the New Testament, a prophet who appears in Acts 11:28 and 21:10 is named Agabus, a variant on the name Hagab.[140] Hagab is a different character from Hagabah, which appears in the preceding verse.
-Nepheg Nepheg was a son of Izhar of the house of Levi according to Exodus 6:21, born in Egypt. He was a nephew of Amram and a cousin of Aaron, Miriam, and Moses.
-Harhas Harhas, according to 2 Kings 22:14 and 2 Chronicles 34:22, was an ancestor of Shallum, the husband of the prophetess Huldah. However, where the Book of Kings has 'Harhas,' the Book of Chronicles reads 'Hasrah.'[155][156]
-Joezer Joezer, according to 1 Chronicles 12:6, is the name of one of the Benjamite warriors who came to the aid of David when he went to Ziklag in Philistine territory due to the hostility of king Saul.
-Abihail #2 wife of Abishur and mother of Ahban and Molid. I Chronicles[4]
-Abihail #1 mother of Zuriel, chief of the house of Merari. Numbers[3]
-Izhar For the Levitical clan, see Izhar. Izhar son of Hela is a figure who appears in a genealogy of the Tribe of Judah, in 1 Chronicles 4:7. He is called Izhar according to the variant reading known as Qere. According to the Ketiv his name is Zohar. The King James Version calls him Jezoar.
-Hagar Egyptian handmaiden of Sarah, wife of Abraham. Hagar became the mother of one of Abraham's sons, Ishmael. Genesis[57]
-Mehujael In Genesis 4:18 ‘Mehujael' is a descendant of Cain, the son of Irad and the father of Methusael. The name means 'El (or) the god enlivens.' [16]
-Matthan Matthan (meaning 'gift') was the grandfather of Saint Joseph. He is mentioned in Matthew 1:15.[14]
-Uriah ben Shemaiah Uriah ben Shemaiah is mentioned in Jeremiah 26:20-23 as a minor prophet from Kiriath-Jearim who 'spoke in the name of the Lord against this city and nation just as Jeremiah did'. King Jehoiakim heard about his activities, and tried to kill him, but Uriah fled to Egypt 'in terror'. Elnathan son of Achbor was sent to return him, and Jehoiakim had him killed when he was brought back to Judah.
-Izrahiah Izrahiah (Jezrahiah) is the name of two biblical figures. Izrahiah son of Uzzi, son of Tola, son of Issachar appears in a genealogy of the Tribe of Issachar.[233] Izrahiah (KJV Jezrahiah) is, according to Nehemiah 12:42, a leader of singers in a procession headed by Nehemiah.
-Stachys Stachys was a 'dear friend' of Paul the Apostle whom he told the church in Rome to greet (see Romans 16:9).
-Isshiah See Jesiah.
-Michal daughter of Saul and wife of David. I Samuel, II Samuel, I Chronicles[131][132][133]
-Jishui Jishui was the second son of King Saul, mentioned in Saul's genealogy in 1 Samuel 14:49. He is called Abinadab in 1 Chronicles 8:33 and 9:39.
-Hachmoni Hachmoni or Hakmoni is mentioned in passing in 1 Chronicles 27:32, which records that his son Yechiel, a scribe, tutored David's sons.[137]
-Vophsi Vophsi of the house of Naphtali was the father of Nahbi, a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:14.
-Mahalath Hebrew: sickness, a company of dancers, or a harp Mahalath, one of the wives of Esau, and a daughter of Ishmael (Genesis 28:6-9). Thought to be the same as Basemath of Genesis 36. Mahalath, a daughter of Jerimoth and Abihail; the wife of king Rehoboam. (1 Chronicles 11:18)
-Jacan Jacan (or Jachan) is a name which appears once in the Hebrew Bible, in a list of Gadites in Chronicles.[243][244]
-Ahishar Ahishar (×חישר in Hebrew; meaning Brother of song, or singer), the officer who was 'over the household' of Solomon (1 Kings 4:6).
-Parnach Parnach was the father of Elizaphan, a prince of the Tribe of Zebulun. (Num. 34:25).
-Susanna #1 a woman who was nearly sentenced to death due to false adultery accusations before being saved by Daniel. Daniel
-Susanna #2 A follower of Jesus. Luke[186]
-Jeremai Jeremai, one of the 'descendants of Hashum,' is a figure who appears only in Ezra 10:33, where he is listed among the men who married foreign women.[285]
-Keren-happuch Keren-happuch, sometimes spelled Kerenhappuch,[311] is the name of Job's third daughter (Job 42:14) who was born after prosperity had returned to him.[312]
-Shiphrah one of two midwives who saved the Hebrew boys. Exodus[155]
-Shelomi Shelomi was the father of Ahihud, a prince of the Tribe of Asher. (Num. 34:27).
-Kelita Kelita ('maiming'[310]) was a Levite who assisted Ezra in expounding the law to the people. (Nehemiah 8:7,10:10) He was also known as Kelaiah. (Ezra 10:23)
-Tamar #3 daughter of David's son Absalom. II Samuel 14:27[190]
-Diklah Diklah was a son of Joktan according to Genesis 10:27, 1 Chronicles 1:21.
-Athlai Athlai, a descendant of Bebai, is listed in the book of Ezra[71] as one of the men who married foreign women. The name is a contraction of 'Athaliah.'[72] In the equivalent list in 1 Esdras,[73] the name 'Amatheis' or 'Ematheis' appears in the same place.[72]
-Harnepher Harnepher appears only once in the Bible, in 1 Chronicles 7:36, in a passage which surveys the descendants of Asher.[157] The name may be of Egyptian origin, meaning 'Horus is good.'[157]
-Maai Maai (Hebrew: מָעַי) was a musician who was a relative of Zechariah, a descendant of Asaph. He is mentioned once, as part of the ceremony for the dedication of the rebuilt Jerusalem wall (Nehemiah 12:36), where he was part of the group that processed southwards behind Ezra.[3] His name is omitted in the Septuagint translation of the passage, as are the names of five other relatives of Zechariah mentioned in the same verse.[4] The name is otherwise unattested.[5] Blenkinsopp suggests that Maai is a diminutive nickname.[5] Mandel proposes its Hebrew origin means 'sympathetic.'[6]
-Matthat 'Gift of God', possibly also translated as Matthan. The son of Levi, and father of Heli (Luke 3:24), great grandfather to Jesus Son of another Levi (Luke 3:29), 31 generations before Jesus and 11 generations after King David
-Hoshama Hoshama is the name of one of the seven sons of Jeconiah, according to 1 Chronicles 3:18, the only place in the Bible that refers to him.[190] It is a shortened version of the name 'Jehoshama.'[190]
-Mishmannah (Hebrew מִשְ××žÖ·× Ö¸Ö¼×” 'fat, sleek') one of the Gadite heroes who gathered to David at Ziklag (1 Chronicles 12:10).
-Zeri See Izri.
-Sachar Sachar (sometimes spelled Sacar or Sakar) was the name of two individuals mentioned in the Bible: One of David's heroes 1 Chronicles 11:35; also called Sharar 2 Samuel 23:33. A son of Obed-Edom the Gittite, and a temple porter 1 Chronicles 26:4.
-Jamlech Jamlech is a figure who appears once in the Hebrew Bible, in list of kin group leaders in the Tribe of Simeon, who according to the Bible lived in the time of Hezekiah and exterminated the Meunim.[255][256]
-Joed Joed is the name of a man mentioned in passing as being an ancestor of Sallu, a Benjamite in the time of Nehemiah.[299]
-Jaziz Jaziz the Hagrite, according to 1 Chronicles 27:31, was in charge of king David's flocks of sheep and goats.
-Birsha Birsha is the king of Gomorrah in Genesis 14 who joins other Canaanite city kings in rebelling against Chedorlaomer.
-Jarah See Jehoaddah.
-Joel Joel is the name of several men in the Hebrew Bible: The firstborn son of the prophet Samuel. According to 1 Samuel chapter 8, Joel and his brother Abijah were appointed by Samuel to be judges in Beersheba, in the south of Israel, while he continued to judge in Ramah. However, Joel and Abijah 'walked not in his ways, but turned aside after lucre, and took bribes, and perverted judgment', prompting the Israelites to demand that Samuel give them a king. Josephus says that 'resigning his office to his sons, he divided the people between them, and placed them in Bethel and Beer-sheba', a statement which the Cambridge Bible for Schools and Colleges suggests 'is probably his own conjecture'.[300] An ancestor of Samuel (mentioned in 1 Chr 6:21).[301] A Simeonite prince (1 Chr 4:35).[301] A Reubenite; father of Shemaiah (1 Chr 5:4–8).[301] A Gadite chief (1 Chr 5:12).[301] A chief of Issachar (1 Chr 7:3).[301] One of David's mighty men, indicated as the brother of Nathan (1 Chr 11:38).[301] A Gershonite, a prince in the time of David (Chronicles 15:7; 23:8; 26:22).[301] Son of Pedaiah; a Manassite chief in the time of David (1 Chr 27:20).[301] A Kohathite in the time of Hezekiah (2 Chr 29:12).[301] One of those who married foreign wives (Ezra 10:43).[301] Son of Zichri; a Benjamite overseer after the Exile (Nehemiah 11:9).[301]
-Malchiel Malchiel (Hebrew מַלְכִּי×ֵל 'my king is God') was a son of Beriah the son of Asher, according to Genesis 46:17 and Numbers 26:45. He was one of the 70 persons to migrate to Egypt with Jacob. According to 1 Chronicles 7:31, he was the ancestor of the Malchielites, a group within the Tribe of Asher.
-Moza (Hebrew ×ž×•Ö¹×¦Ö¸× 'escape route' said of flowing water, the rising sun, leafing plants, etc.) One of the sons of Caleb (1 Chronicles 2:46). The son of Zimri, of the posterity of Saul (1 Chronicles 8:36-37),(1 Chronicles 9:42-43).
-Allon In 1 Chronicles 4:37, Allon is the son of Jedaiah, of the family of the Simeonites, who expelled the Hamites from the valley of Gedor.
-Q [icon] This section is empty. You can help by adding to it. (February 2015)
-Rekem This is about individuals in the Bible named Rekem. For the city by that name, see List of minor biblical places § Rekem. Rekem is a personal name used several times in the Hebrew Bible, for more than one individual. Rekem was one of five Midianite kings killed during the time of Moses by an Israelite expedition led by Phinehas, son of Eleazar according to Numbers 31:8 and Joshua 13:21. According to 1 Chronicles 2:43-44, Hebron, a figure associated with the biblical Caleb, was the father of a person named Rekem. According to 1 Chronicles 7:16, Machir the son of Manasseh was the ancestor of a figure named Rekem. In this last passage, the King James Version spells the name as Rakem.
-Jecamiah See Jekamiah.
-Jemima #2 One of Job's daughters. Job[83]
-Gemalli Gemalli of the house of Dan was the father of Ammiel, a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:4.
-Jahzeel Jahzeel was a son of Naphtali according to Genesis 46:24 and Numbers 26:48. He was one of the 70 persons to migrate to Egypt with Jacob.
-Zabad Zabad is the name of seven men in the Hebrew Bible. Zabad means gift or endowment.[citation needed] In 1 Chronicles 2:36-37, Zabad is a member of the Tribe of Judah, the family of Hezron and the house of Jahahmeel. He was the son of Nathan and the father of Ephlal. In 1 Chronicles 7:21, Zabad is an Ephraimite of the family of Shuthelah. He was the son of Tanath and the father of Suthelah. In 1 Chronicles 11:41, Zabad is one of King David's mighty men. He is the son of Ahlai. In 2 Chronicles 24:26, Zabad is one of two servants of King Joash who kill him in his bed. He is the son of Shimeath, an Amonite woman. In 2 Kings 12:21 this same man seems to be called Jozachar (Hebrew: יוֹזָכָר‎‎; Latin: Josachar). His fellow conspirator is Jehozabad (Hebrew: יהוֹזָבָד‎‎; Latin: Jozabad), the son of Shomer (Hebrew: שֹ×מֵר‎‎; Latin: Somer). In Ezra 10:27,33,34, three men named Zabad are listed as having taken foreign wives, whom Ezra persuades them to send away.
-Jekamiah Jekamiah (KJV spelling Jecamiah) is the name of two individuals in the Hebrew Bible.[281] Jekamiah son of Shallum, son of Sismai, son of Eleasah, son of Helez, son of Azariah, son of Jehu, son of Obed, son of Ephlal, son of Zabad, son of Nathan, son of Attai, son of Jarha, the son-in-law and slave of Sheshan, son of Ishi, son of Appaim, son of Nadab, son of Shammai, son of Onam, son of Jerahmeel, the alleged ancestor of the Jerahmeelites.[282] Jekamiah, a son of Jeconiah, the last king of Judah, who was taken captive by the Babylonians.[283]
-Rizpah daughter of Aiah and one of the concubines of King Saul. II Samuel[169]
-Abinadab Abinadab (Hebrew ×Ö²×‘Ö´×™× Ö¸×“Ö¸×‘ 'my father apportions' or 'the father [i.e. god of the clan] is munificent') [15] refers to four biblical characters. Where the Hebrew text reads Avinadav, Greek manuscripts of the Septuagint read Am(e)inadab or Abin.[15] but Brenton's translation of the Septuagint reads 'Abinadab'. A man of Kirjath-jearim, in whose house on a hill the ark of the covenant was deposited after having been brought back from the land of the Philistines.[16] 'It is most likely that this Abinadab was a Levite'.[17] The ark remained in his care for twenty years, guarded by his son Eleazar (not to be confused with Eleazar, the son of Aaron), until it was at length removed by David.[18] The second of the eight sons of Jesse.[19] He was with Saul in the campaign against the Philistines in which Goliath was slain.[20] One of Saul's sons, who perished with his father in the battle of Gilboa.[21] Ben-abinadab; One of Solomon's officers, who 'provided victuals for the king and his household'. He presided for this purpose over the region of Dor and had Taphath a daughter of Solomon as his wife.[22]
-Pethahiah Pethahiah is the name of two individuals named in the Bible. A levite, mentioned in Nehemiah 10:23 and Nehemiah 9:5. Pethahiah ben Meshezabel, who was one of the 'sons of Zerah' of the Tribe of Judah. In addition to these individuals, Pethahiah was the eponym of one of the biblical priestly divisions.
-Zipporah wife of Moses, daughter of Jethro. Exodus[198]
-Sharar A Sharar is mentioned indirectly in 2 Samuel 23:33, where 'Ahiam the son of Sharar the Hararite' is listed as one of David's Mighty Warriors. In 1 Chronicles 11:35, the same figure is referred to as Sacar (sometimes spelled Sakar or Sachar).
-Sheconiah Sheconiah was a descendant of David, father of Shemaiah, and son of Obadiah.
-Immer Immer was a member of the priestly family whose sons, Hanani and Zebadiah, had both taken pagan wives but repented during the communal confession instigated by the biblical priest Ezra.[204]
-Irijah Irijah (Hebrew יר××™×™×” yiriyyah) is an official who arrests Jeremiah on suspicion of desertion.[212]
-Mahazioth Heb. 'Visions', a Kohathite Levite, chief of the twenty-third course of musicians 1 Chronicles 25:4,1 Chronicles 25:30
-Ben Hesed Ben Hesed (Hebrew ×‘× ×—×¡×“ ben hesed 'Son of Grace'), was one of King Solomon's twelve regional administrators; he was over Aruboth, Sochoh, and Hepher. I Kings 4:10 (RSV).
-Linus Linus was an associate of Paul the Apostle who greeted Saint Timothy in 2 Timothy 4:21.
-Amzi Amzi ('am-tsee') is a masculine Hebrew name meaning 'my strength' or 'strong.' Two individuals with this name are mentioned in the Bible: 1 Chronicles 6:31 indicates Amzi as a Levite man of the family of Merari. A son of Zechariah was named Amzi. He was an ancestor to the Levite priest Adaiah (Nehemiah 11:12), who was one of the Israelite exiles under the direction of Nehemiah when he returned to Jerusalem to rebuild the city walls.
-Jehoaddan Jehoaddan (Hebrew: יהועדן, YehÅaddÄn; 'YHWH delights') was a native of Jerusalem, the wife of King Joash of Judah, and mother of his successor, King Amaziah. II Kings 14:2
-Jaresiah See Jaareshiah.
-Likhi Likhi son of Shemida is listed in a genealogy of the Tribe of Manasseh. He is mentioned only in 1 Chronicles 7:19.[2]
-Ishpan Ishpan is a figure who appears only once in the Hebrew Bible, in a genealogical passage describing the people of the Tribe of Benjamin.[222] 1 Chronicles 8 calls him the son of Shashak, the son of Elpaal, the son of Shaharaim.[223]
-Ishpah Ishpah (KJV Ispah) is a name which appears in a genealogy of the Tribe of Benjamin.[219][220] According to 1 Chronicles 8, Ishpah was the son of Beriah, the son of Elpaal, the son of Shaharaim.[221]
-Harum Harum is recorded as the father of Aharhel in 1 Chronicles 4:8, which lists him as an ancestor of several clans in the Tribe of Judah.
-Antiochus a royal concubine who was given the cities of Tarsus and Mallus as gifts. 2 Maccabees[21]
-Heldai Heldai is the name of two biblical figures.[172] According to the Encyclopaedia Biblica, it should most likely be given alternate vowels as Holdai or Huldai.[172] Heldai son of Baanah the Netophathite is listed as one of David's Mighty Warriors, and also in a list of military leaders given in 1 Chronicles 27:15. He is called 'Heled' in 1 Chronicles 11:30, and 'Heleb' in 2 Samuel 23:29.[172] A Jew living in Babylonia, mentioned in Zechariah 6:10. He is called Helem in Zechariah 6:10.[172]
-Hazo Hazo was the son of Nahor and Milcah (Genesis 22:22).
-Tola Tola (Hebrew: תּוֹלָע, Modern TolaÊ», Tiberian TôlÄÊ»; 'Worm; grub') was the name of two individuals mentioned in the Bible: A son of Issachar according to Genesis 46:13, Numbers 26:23 and 1 Chronicles 7:1. He was one of the 70 souls to migrate to Egypt with Jacob. Tola (biblical figure), also of the tribe of Issachar, one of the judges of Israel (Judges 10:1-2).
-Meshelemiah 'Friendship of Jehovah', a Levite of the family of the Korhites, called also Shelemiah (1 Chronicles 9:21),(1 Chronicles 26:1-14) He was a temple gate-keeper in the time of David.
-Mehir Mehir son of Chelub appears in a genealogy of the Tribe of Judah in 1 Chronicles 4:11.
-Kemuel Kemuel Prince of the tribe of Ephraim; one of those appointed by Moses to superintend the division of Canaan amongst the tribe (Num. 34:24).
-Azubah #1 Caleb's wife. I Chronicles[26]
-Ilai See Zalmon (biblical figure).
-Azubah #2 wife of King Asa, 3rd king of Judah, and mother of Jehoshaphat. I Kings, II Chronicles[27][28]
-Delilah The 'woman in the valley of Sorek' whom Samson loved. Judges[44]
-Zuar Zuar was a member of the house of Issachar according to Numbers 1:8. He was the father of Nethaneel.
-Putiel Putiel was the father of Eleazar's wife according to Exodus 6:25. According to Rashi this was another name of Jethro.
-Salu Salu, of the house of Simeon, was the father of Zimri who was involved in the Heresy of Peor according to Numbers 25:14.
-Deborah #1 Nursemaid to Rebekah and later to Jacob and Esau. Genesis[42]
-Helek Helek was a son of Gilead of the Tribe of Manasseh according to Numbers 26:30 and Joshua 17:2.
-Carmi Carmi refers to two individuals mentioned in the Bible: The fourth son of Reuben according to Genesis 46:9, Numbers 26:6, and 1 Chronicles 5:3. The son of Zabdi, grandson of Zerah of the Tribe of Judah, and the father of Achan, according to Joshua 7:1. He was present at the Battle of Jericho.
-Medium of En Dor 1 Samuel 28[127]
-Zeresh wife of Haman. Esther[193]
-Jozachar Jozachar (Hebrew: יוֹזָכָר, yozakhar, 'God Remembered') or Jozacar, son of Shimeath, was one of the assassins of king Joash of Judah. In 2 Kings 12:21 the Hebrew is יוזבד, yozabad.
-Meshullam Meshullam, meaning 'befriended', was the name of eleven biblical individuals. (See Meshullam.)
-Machnadebai Machnadebai is mentioned in the Hebrew Bible only once, in Ezra 10:40, where the name appears in a list of people alleged to have married foreign women.[8]
-Paseah Paseah is the name of two figures in the Hebrew Bible. In a genealogy of Judah, a Paseah appears (1 Chronicles 4:12) as the son of Eshton, the son of Mehir, the son of Chelub. Another Paseah is mentioned indirectly (Nehemiah 3:6) by way of his son Jehoiada, a repairer of a section of the wall of Jerusalem.
-Piram Piram, according to Judges 10:3, was the king of Jarmuth.
-Caleb, son of Hezron This is about the Caleb mentioned only in 1 Chronicles 2:18. For the better-known Caleb son of Jephunneh, see Caleb. See Caleb (son of Hezron).
-Zichri Zichri was a son of Izhar of the house of Levi according to Exodus 6:21, born in Egypt. He was a nephew of Amram and a cousin of Aaron, Miriam, and Moses.
-Michael Michael of the house of Asher was the father of Sethur, a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:13.
-Baara Baara was one of the three wives of Shaharaim, according to 1 Chronicles 8:8.
-Jezer Jezer was a son of Naphtali according to Genesis 46:24 and Numbers 26:49. He was one of the 70 persons to migrate to Egypt with Jacob. According to Numbers he was the progenitor of the Jezerites.
-Adah Hebrew: עָדָה, Modern Ê¿Ada, Tiberian Ê¿Ä€á¸Äh; adornment[25] the first wife of Lamech, and the mother of Jabal and Jubal. (Genesis 4:19-23) the first wife of Esau, the daughter of Elon the Hittite. It has been suggested by biblical scholars that she is the same person as 'Bashemath the daughter of Elon the Hittite' mentioned as a wife of Esau in Genesis 26.[26][27] She bore Esau's firstborn Eliphaz, and became the matriarch of the Edomites. (Genesis 26:34,36:2-4) The Order of the Eastern Star considers Adah also to be the name of the daughter of Jephthah, although the Bible does not name her.
-Vaniah Vaniah, meaning nourishment, or weapons, of the Lord; one of many sons of Bani named in Ezra 10:36.
-Nebat Nebat (Hebrew: × ×‘×˜ nebat 'Sprout'), an Ephrathite of Zereda, was the father of Jeroboam.[28]
-Chenaanah Chenaanah is the name of two biblical figures. In a genealogical section of Chronicles concerned with the Tribe of Benjamin, a Chenaanah son of Bilhan is mentioned.[86] The false prophet Zedekiah is called 'son of Chenaanah.'[87]
-Hallohesh Hallohesh or Halohesh is a name which is used twice in the Bible.[143] In a list of workers building the wall of Nehemiah, a man named 'Shallum son of Hallohesh' is mentioned as having a leadership role.[144] Also in the Book of Nehemiah, a person named Hallohesh is recorded as affixing his seal (an ancient form of signature) to Ezra's covenant between God and the people living around Jerusalem.[145] Thomas Kelly Cheyne believed that the name Hallohesh was a miswritten version of the name Hash-shilhi, (Shilhi).[143]
-Arodi Arodi or Arod was a son of Gad according to Genesis 46:16 and Numbers 26:17. He was one of the 70 souls to migrate to Egypt with Jacob.
-Eri In Genesis 46:16 Eri (עֵרי 'watchful') is the son of Gad. He was the progenitor of the Erites. (Numbers 26:16)
-Ezrah Ezrah is the father of Jether, Mered, Epher and Jalon, grandfather (through Mered) of Miriam, Shammai and Ishbah, and great-grandfather (through Ishbah) of Eshtemoa (1 Chr. 4:17)
-Ahishahar Ahishahar is the name given to a third-generation descendant of Benjamin (the eponymous forefather of the Tribe of Benjamin) in 1 Chronicles 7:10. This figure is mentioned nowhere else in the Hebrew Bible.[42]
-Mehetabeel Mehetabeel ('Whom God benefits' or 'God causes good') was the father of Delaiah, and grandfather of Shemaiah, who joined Sanballat against Nehemiah (Nehemiah 6:10).
-Shedeur Shedeur was a member of the house of Reuben according to Numbers 1:5. He was the father of Elizur.
-Ahasai See Ahzai.
-Adna Adna is the name of two biblical characters.[31] The first is one of the men in the Book of Ezra who took foreign wives.[32] The second is a priest, named as the head of the priestly family Harim in the time of Joiakim.[33]
-Abdeel Abdeel (Ab'dÄ“el) (Hebrew עַבְדְּ×ֵל 'servant of God'; akin to Arabic عبد الله Abdullah [1]) is mentioned in Jeremiah 36:26 as the father of Shelemiah, one of three men that were commanded by King Jehoiakim to seize the prophet Jeremiah and his secretary Baruch.[2] The Septuagint omits the phrase 'and Shelemiah son of Abdeel', probably a scribal error due to homoioteleuton.[3]
-Joshah Joshah son of Amaziah is mentioned only once in the Bible, where is listed among Benjamite leaders in 1 Chronicles 4:34.[302] He is one of several clan leaders who, according to Chronicles, were involved in exterminating the descendants of Ham and the Meunim, and taking their pasture-lands.
-Arnan Arnan was a descendant of David, father of Obadiah, and son of Rephaiah.
-Chelal See Kelal.
-Elzabad Elzabad is the name of two biblical figures. Elzabad appears ninth in a list of eleven warriors from the Tribe of Gad who, according to 1 Chronicles 12:12, joined forces with David 'at the stronghold in the wilderness.' Elzabad, the son of Shemaiah, the son of Obed-edom, is listed as a Korahite porter in 1 Chronicles 26:7.
-Merab #2 King Saul's oldest daughter. I Samuel[128]
-Mehetabel #2 daughter of Matred. Genesis; I Chronicles[125][126]
-Rosh Hebrew: ר×ש rosh 'Head' Rosh is the seventh of the ten sons of Benjamin named in Genesis 46:21. A nation named Rosh is also mentioned in Ezekiel 38:2-3; 39:1 'Son of man, set your face toward Gog, the land of Magog, the prince of Rosh, Meshech, and Tubal; and prophesy concerning him.' Also in a variant reading of Isaiah 66:19 (MT) and the Septuagint Jeremiah 32:23. Most scholars see this as a mistranslation of × Ö°×©Ö´×‚Ö•×™× ×¨Ö¹Ö–×ש×, nesi ro’š ('chief prince'), rather than a toponym.
-Jezebel #1 Queen of ancient Israel. I Kings, II Kings[87][88]
-Jezebel #2 false prophetess. Revelation[89]
-Mahali Mahali (also Mahli) was a son of Merari of the house of Levi according to Exodus 6:19, born in Egypt.
-Esther (also known as Hadassah) Queen of the Persian Empire in the Hebrew Bible, the queen of Ahasuerus. Esther[52]
-Joshibiah Joshibiah (King James Version spelling Josibiah) is given in 1 Chronicles 4:35 as the father of Jehu, one of the Benjamite clan leaders in the time of Hezekiah who exterminated the descendants of Ham and the Meunim and took their farmland.[305]
-Pelatiah Pelatiah (Hebrew: פלטיהו Pelatyahu 'Refugee of God' Ezekiel 11:1) son of Benaiah, a prince of the people, among the 25 Ezekiel saw at the East Gate; he fell dead upon hearing the prophecy regarding Jerusalem.
-Romamti-ezer Romamti-ezer is the name of a figure who appears twice in the Hebrew Bible, both times in 1 Chronicles 25. In verse 4 he is identified as one of the fourteen sons of Heman, one of three men who according to Chronicles were assigned to be in charge of musical worship in the Temple of Jerusalem. Later in the chapter, 288 assigned to the musical service are divided into twenty-four groups of twelve. The twenty-fourth group is assigned to Romamti-ezer (verse 31).
-Jaasau See Jaasu.
-Jaasai See Jaasu.
-Ibnijah Ibnijah is a figure who is mentioned indirectly in 1 Chronicles 9:8, by way of his descendant 'Meshullam, son of Shephatiah, son of Reuel, son of Ibnijah.' He was a Benjamite.[197]
-Elead Elead appears in 1 Chronicles 7:21 as the name of a man who, along with his brother Ezer, is killed by farmers near Philistine the city of Gath. It is unclear whether Elead is intended by the Chronicler as the son or a later descendant of Ephraim, and it is likewise uncertain whether this Elead is the same figure as the Eleadah mentioned in the previous verse.[98]
-Baara #2 Moabitess, wife of Shaharaim. I Chronicles[29]
-Elionenai Elionenai was a descedant of David. He was the father of Akkub, and son of Neariah.
-Shaphat Shaphat, the son of Hori of the house of Simeon, was a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:5. Also the name of one of King David's sons by Bathsheba.
-Orpah Sister-in-law to Ruth. Ruth[147]
-Hezekiah This section is about the minor biblical figures named Hezekiah. For the king Hezekiah, see Hezekiah. Hezekiah is the name of three minor figures in the Hebrew Bible. In some Bibles the variant spellings Hizkiah and Hizkijah occur. A son of Neariah and descendant of David mentioned in the royal genealogy of 1 Chronicles 3.[179] A figure mentioned in passing in Ezra 2:16 and Nehemiah 7:21, as the ancestor of some of the exiles who returned from the Babylonian captivity. An ancestor of the prophet Zephaniah.[180]
-Martha Luke, John[109][110]
-Meremoth 'Exaltations, heights', a priest who returned from Babylon with Zerubbabel (Nehemiah 12:3), to whom were sent the sacred vessels (Ezra 8:33) belonging to the temple. He took part in rebuilding the walls of Jerusalem (Neh 3:4).
-Shaashgaz Shaashgaz is a name which appears in the Hebrew Bible only in Esther 2:14, where it is given as the name of the eunuch who was in charge of the 'second house of the women.'
-Keziah Keziah ('Cassia') is the name of Job's second daughter.[313]
-Job Job or Jashub was a son of Issachar according to Genesis 46:13, Numbers 26:24 and 1 Chronicles 7:1. He was one of the 70 souls to migrate to Egypt with Jacob.
-Habaiah Habaiah (also called Hobaiah or Obdia) was the name given to a priestly family mentioned in Ezra 2:61: the b'ne habayah (literally 'sons/descendants of Habaiah').[132][133] Along with the families Hakkoz and Barzillai, the Habaiah family were priests whose names were not registered in the official genealogical records.[134] As a result, Ezra ruled that their rights to serve as priests would be restricted until such time as a high priest could decide, using the oracular Urim and Thummim, whether they had divine approval to serve as priests.[135] The name 'Habaiah' means 'Yahweh hides' or 'Yahweh protects,' and appears in manuscripts of the Greek Septuagint in the forms Labeia, Obaia, Odogia, Ebeia, Ab(e)ia, Obbeia, and Obdia. [133]
-Hakkoz Hakkoz is the name of two or three biblical individuals: Head of the seventh of twenty-four priestly divisions created by King David. (1 Chr. 24:10) Head of a family of priests after the Babylonian exile. Unable to prove their lineage, the family lost its priesthood status. (Ezr. 2:61, Neh. 7:63) Father of Uriah and grandfather of Meremoth, who assisted Nehemiah in rebuilding the walls of Jerusalem. (Neh. 3:4, 3:21) He is probably identical to the previous entry.
-Melech King, the second of Micah's four sons 1 Chronicles 8:35), and thus grandson of Mephibosheth. Also related to a southwest Asian god, see Melech
-Hubbah See Jehubbah.
-Mibsam 'Fragrance' One of Ishmael's twelve sons, and head of an Arab tribe (Gen 25:13). A son of Simeon (1 Chronicles 4:25).
-Ahab Ahab (Hebrew: ×ָח×ַב, which means 'brother/father') is the name of at least two biblical figures: Ahab, seventh king of Israel Ahab, son of Koliah, who, according to Jeremiah 29:21, was labeled a false prophet by YHVH [38]
-Machbena Machbena or Machbenah, according to the only mention of him, in 1 Chronicles 2:49, was the son of Sheva the son of Caleb.
-Dodo Dodo (Hebrew דּוֹדוֹ dodo from דּוֹד dod meaning 'beloved' or 'father's brother') is a name given to three persons in the Bible: A descendant of Issachar (Judges 10:1). An Ahohite, father of Eleazar, who was one of David's three mighty men who were over the thirty. (2 Samuel 23:9; 1 Chronicles 11:12) A man from Bethlehem, and father of Elhanan, who was one of David's thirty heroes (2 Samuel 23:24).
-Salome #2 a follower of Jesus present at his crucifixion as well as the empty tomb. Mark[174]
-Salome #1 daughter of Herodias. Name in Hebrew reads שלומית (Shlomit) and is derived from Shalom שלו×, meaning 'peace'. Matthew, Mark[172][173]
-Uri Uri is mentioned 7 times, 6 of which indicate that another figure is the 'son of Uri'. The meaning of the name in English is 'my light', 'my flame' or 'illumination'. Uri (Hebrew: ×וּרִי) is mentioned in Exodus 31 and 1 Chronicles 2 as a member of the Tribe of Judah. He is the son of Hur (Hebrew: חור) and the father of Bezalel (Hebrew: בצל×ל). Another Uri (Hebrew: ×וּרִי) is mentioned in Ezra 10 as one of those who have taken 'strange wives.'
-Enoch See also: Enoch (son of Cain) In Genesis 4:17-18, Enoch is the firstborn son of Cain and the father of Irad. Cain named the city of Enoch after his son.
-Mash Mash was a son of Aram according to Genesis 10:23.
-Segub Segub (שגוב‎ “He has revealed Himself as exalted†or “He has protected.â€[37]) was the youngest son of Ahab[38]
-Mehetabel Mehetabel ('Whom God benefits' or 'God causes good') was the wife of Hadad, one of the kings of Edom (Genesis 36:39).
-Sered Sered was a son of Zebulun according to Genesis 46:14 and Numbers 26:26. He was one of the 70 souls to migrate to Egypt with Jacob. According to the verse in Numbers, he was the eponymous forefather of the clan of Sardites.
-Jeshishai Jeshishai is a figure mentioned only once, in passing, in a genealogy of Gad.[288][289]
-Bukki Bukki was a prince of the tribe of Dan; one of those appointed by Moses to superintend the division of Canaan amongst the tribe (Num. 34:22).
-Mijamin Mijamin (also spelled Miamin, Miniamin, Minjamin) ('from the right hand') is the name of three persons mentioned in the Bible: The head of the sixth of twenty four priestly divisions set up by King David. (1 Chronicles 24:9) A chief priest who returned from Babylon with Zerubbabel (Neh 12:5), who signed the renewed covenant with God. (Neh 10:8) In the time of Joiakim his family had joined with that of Moadiah, and was led by Piltai. He was also called Miniamin. (Neh 12:17) A non-priestly Mijamin son of Parosh is mentioned in Ezra 10:25 as one of those who divorced a gentile wife, and sacrificed a ram in atonement.
-Seled According to 1 Chronicles 2:1-30, in the genealogical section which begins the book of Chronicles, Seled, who died childless, was the brother of Appaim and son of Nadab, the son of Shammai, the son of Onam, the son of Jerahmeel, the son of Hezron, the son of Perez, the son of Judah, the eponymous founder of the Tribe of Judah.
-Rebekah wife of Isaac and the mother of Jacob and Esau. Genesis, Romans[165][166]
-Lahmi Lahmi, according to 1 Chronicles 20:5, was the brother of Goliath, killed by David's warrior Elhanan. See also Elhanan son of Jair.
-Delaiah Delaiah (דליהו 'drawn out by YHWH').[93] is the name of several biblical persons: Kohenic family, one of the Twenty-four Priestly divisions Son of Shemaiah, and officer to King Jehoiakim of Judah. He was one of the officers present at the delivery of a scroll sent by Jeremiah, (Jer. 36:12) and one of those who asked the king not to burn the scroll. (ibid. 36:25) Son of Elioenai, a descendant of the royal Davidic line through Jeconiah. (1 Chr. 3:24) The head of a family that came up from the Babylonian exile with Zerubbabel, that was unable to give its ancestral genealogy. (Ezr. 2:60, Neh. 7:62) Son of Mehetabel and father of Shemaiah. (Neh. 6:10) He is probably identical to the previous entry.
-Hori Hori is the personal name of two biblical individuals, as well as being the Hebrew term for a Horite. Hori of the house of Simeon was the father of Shaphat, a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:5. Hori is recorded as the name of Lotan, the son of Seir the Horite, according to Genesis 36:22.
-Ziza Ziza (or Zizah) was a Gershonite, the second son of Shimei (1 Chronicles 23:10-11). The spelling is according to the Septuagint; most Hebrew manuscripts have Zina.[55]
-Jesui See Ishvi.
-Elon Elon (Hebrew: ×ֵילֹן, Modern Elon, Tiberian ʼÊlÅn; 'Oak') was the name of two individuals mentioned in the Bible: A son of Zebulun according to Genesis 46:14 and Numbers 26:26. He was one of the 70 souls to migrate to Egypt with Jacob. Elon, one of the judges of Israel.
-Gazez In the Masoretic Text of the Hebrew Bible, two individuals by the name of Gazez appear in 1 Chronicles 2:46. However, the Peshitta includes only one Gazez, and at least one biblical scholar has suggested that the second Gazez may have been included in the Masoretic Text by mistake.[123] 1. Gazez was the son of Haran, grandson of Caleb, a descendent of Jacob. His paternal grandmother was Ephah, wife of Caleb. (1Chronicles 2:46) 2. Gazez was a brother of Caleb, and uncle of 1. Gazez. (1Chronicles 2:46)
-Lo–Ruhamah Daughter of Hosea and Gomer. Hosea[102]
-Ishvi Ishvi (KJV Ishui, Isui, Jesui, and Ishuai) is the name of two figures in the Hebrew Bible.[225] Ishvi is the name given to a son of Asher, eponymous founder of the Tribe of Asher, in Genesis 46:17, Numbers 26:44, and 1 Chronicles 7:30. His descendants are called Ishvites in Numbers 24:44. Genesis 46 places him in the list of 70 persons who went down into Egypt with Jacob, the father of Asher and the other eleven Tribes of Israel. Ishvi is the name of a son of Saul in 1 Samuel 14:49.
-Reumah Reumah, according to Genesis 22:24, was the concubine of Abraham's brother Nahor, and the mother of his children Tebah, Gaham, Tahash, and Maachah.
-Aphiah Aphiah, of the tribe of Benjamin, was an ancestor of King Saul and of his commander Abner. According to Saul, his family was the least of the tribe of Benjamin.[59]
-Aduel Aduel, according to the Book of Tobit 1:1, was the great-grandfather of Tobit. The Book of Tobit is included in some Christian Bibles, but it is not included in Bibles historically used by Jews and most Protestants. Cheyne and Black claim that 'Aduel' is 'no doubt another form of Adiel.'[35]
-Guni Guni was a son of Naphtali according to Genesis 46:24 and Numbers 26:48. He was one of the 70 souls to migrate to Egypt with Jacob.
-Aristobulus Aristobulus is apparently the patriarch of a household; Paul of Tarsus instructed his followers to greet 'those who belong to the household of Aristobulus'. Romans 16:10.
-Izri Izri (Zeri) appears in a list of persons responsible for liturgical music in the time of David, according to 1 Chronicles 25:11. In 1 Chronicles 25:3, he is called Zeri.[234]
-Eleasah See Elasah.
-Izziah Izziah (KJV Jeziah), a descendant of Parosh, is listed as one of the men who married foreign wives in the time of Nehemiah.[235]
-Bathsheba wife of Uriah the Hittite and later of David, king of the United Kingdom of Israel and Judah. She was the mother of Solomon, who succeeded David as king. II Samuel, I Kings, I Chronicles[33][34][35]
-Ashbel Ashbel (Hebrew, ×שבל) is the third of the ten sons of Benjamin named in Genesis. He founded the tribe of Ashbelites.[68]
-Ahzai Ahzai (KJV Ahasai) is a name which appears only in Nehemiah 11:13, where it is mentioned in passing.[48] The verse refers to a priest, called 'Amashsai son of Azarel son of Ahzai son of Meshillemoth son of Immer.' In the parallel name in 1 Chronicles 9:12, the name 'Jahzerah' replaces 'Ahzai.'[48]
-Hazaiah Hazaiah is a figure mentioned in passing in Nehemiah 11:5 as an ancestor Maaseiah, a notable leader of the Tribe of Judah in Yehud Medinata.[171]
-Mithredath (Hebrew: מִתְרְדָת‎‎; Greek: ΜιθÏαδάτης; Latin: Mithridates) Meaning given by Mithra, or dedicated to Mithra, i.e., the sun, the Hebrew form of the Persian name Mithridates. The 'treasurer' of King Cyrus (Ezra 1:8). Ezra 4:7, a Persian officer in Samaria
-Ben Hur Ben Hur (Hebrew ×‘× ×—×•×¨ Ben Hur 'Son of Hur') was one of King Solomon's twelve regional administrators; he was over Ephraim. I Kings 4:8 (RSV).
-Jezebel Jezebel was a false prophetess whom Jesus warned the church in Thyatira not to follow. She encouraged her followers to be promiscuous and to eat food sacrificed to idols. Jesus gave her a chance to repent of her sins, but she did not; thus, Jesus promised to punish her (see Revelation 2:20-23).
-Iram Iram is a name which appears in Genesis 36:43. In the Masoretic Text as it now stands, Iram is identified as a 'tribal leader' (Hebrew alluph) of Edom. However, Thomas Kelly suggests that originally the text may have identified Iram and the other 'tribal leaders' as the names not of individuals, but of clans, using the Hebrew word eleph to mean 'clan.'[210]
-Hattil The descendants of Hattil (also called Agia or Hagia) are listed in Ezra 2:57 and Nehemiah 7:59 as a group of people returning from the Babylonian captivity (see Ezra-Nehemiah). They are categorized by Ezra as being descendants of 'Solomon's servants' (see Nethinim). In the Greek text of 1 Esdras 5:34, a closely related work, Hattil is referred to as Agia or Hagia.[170]
-Jahmai For the Jahmai of 1 Chronicles 7:2, see List of minor biblical tribes § Jahmai.
-Carshena Carshena or Karshena is a name which appears in a list of high-ranking officials in the court of king Ahasuerus in Esther 1:14. It is derived from the Persian warkaÄÄ«nÄ, meaning 'wolfish.'[82]
-Levi Levi (Hebrew לֵוִי 'unite') was the name of two minor figures mentioned in the Bible. For the more famous biblical character by this name, see Levi. The great-great-grandfather of Jesus; son of Melchi and father of Matthat. (Luke 3:24) Another ancestor of Jesus. (Luke 3:29)
-Irad In Genesis 4:18, Irad is the son of Enoch, the grandson of Cain and the father of Mehujael.
-Lo-Ammi Lo-Ammi (Hebrew for 'not my people') was the youngest son of Hosea and Gomer. He had an older brother named Jezreel and an older sister named Lo-Ruhamah. God commanded Hosea to name him 'Lo-Ammi' to symbolize his anger with the people of Israel (see Hosea 1:1-9).
-Ittai Ittai (and in Chronicles, Ithai once) is the name given one or two biblical figures: Ittai the Gittite appears alongside 600 soldiers as a Philistine ally of David in the time leading up to Absalom's rebellion.[230] Having only recently arrived in Jerusalem, David gives him an option to return home to Gath, but Ittai confirms his loyalty to David and helps him evacuate the city.[231] During the rebellion itself, he serves as commander of a third of David's army.[230] Ittai 'son of Ribai, from Gibeah, of the children of Benjamin' is listed as one of David's Mighty Warriors.[232] His association with Gibeah and the Tribe of Benjamin 'probably' distinguish him from the Gittite Ittai, according to Stanley Arthur Cook.[230] This Benjamite Ittai is once called Ithai in 1 Chronicles 11:31.[230]
-Enan #2 For the place-name containing Enan, see Hazar Enan. Enan was a member of the house of Naphtali according to Numbers 1:15. He was the father of Ahira.
-Enan #1 Enan is mentioned several by way of reference to his son, 'Ahira the son of Enan,' who according to the Book of Numbers was the tribal leader of the Tribe of Naphtali in the time of the wilderness wanderings following the Exodus.[115]
-Phalti For the individual called 'Phalti' in the King James Bible, see Palti, son of Laish.
-Adnah Adnah is the name of at least two individuals in the Hebrew Bible.[34] Adnah, called Ednaas or Ednas in Septuagint manuscripts, is credited with being a commander of 300,000 soldiers in the army of Jehoshaphat.[34] He is found in 2 Chronicles 17:14. His name is spelled with a final He.[34] Adnah, called Edna in the Septuagint, refers to a member of the Tribe of Manasseh who deserted Saul to support David.[34] His name is spelled with either a final He or else a Heth, depending on the manuscript.[34]
-Alexander Alexander was a member of the Sanhedrin named in Acts 4:6 as part of a group before whom Peter and John were required to give an account of their healing power, following their arrest on the day of Pentecost.
-Raphu Raphu of the house of Benjamin was the father of Palti, a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:9.
-Homam See Hemam.
-Basemeth #1 daughter of Elon, the Hittite, One of the wives of Esau. Genesis[30]
-Abitub The name Abitub or Abitob appears only once in the Hebrew Bible, in 1 Chronicles 8:11, where it is used for a character said to be the son of Shaharaim, in a section on the descendants of Benjamin.[24]
-Basemeth #3 daughter of Solomon, wife of Ahimaaz. I Kings[32]
-Basemeth #2 daughter of Ishmael and 3rd wife of Esau. Genesis[31]
-Tirzah one of the daughters of Zelophehad. Numbers, Joshua[71][108]
-Azaliah Azaliah is mentioned in passing as the father of the scribe Shaphan in 2 Kings 22:3 and the copy of the same verse found in 2 Chronicles 34:8. The name means 'Yahweh has reserved.'[74]
-Jozabad Jozabad is the name of several individuals mentioned in the Hebrew Bible. For three other individuals with a similar name, see Jehozabad. Jozabad of Gederah is listed as one of David's warriors in 1 Chronicles 12:4. Two men named Jozabad from the Tribe of Manasseh are listed as warriors of David in 1 Chronicles 12:20. Jozabad, according to 2 Chronicle 31:13, was an overseer in the Temple at Jerusalem in the time of Hezekiah. A Jozabad is described as a Levite leader in 2 Chronicles 35:9. This may be the same individual overseeing the Temple in the time of Hezekiah.[307] Jozabad son of Joshua is listed as a Levite in the time of Ezra in the time of Ezra 8:33. A Levite Jozabad is listed in Ezra 10:22 as having taken a foreign wife. A Levite Jozabad is listed as having a foreign wife in Ezra 10:23. This man may be the same as Joshua son of Joshua mentioned above, and/or the same as the two individuals below.[307] A Jozabad is listed in Nehemiah 8:7 as one of those who helped explain the law to the people of Yehud Medinata. A Jozabad is listed as one of the inhabitants of Jerusalem in Nehemiah 11:16.
-Harim 'Harim' redirects here. For the city in Syria, see Harem, Syria. Harim (Hebrew: חָרִ×‎‎; 'destroyed' or 'dedicated to God') was the name of three biblical patriarchs: Head of the third of twenty-four priestly divisions instituted by King David. (1 Chr. 24:8) Head of a non-priestly family, with 320 members, which returned with Zerubbabel. (Ezr. 2:32, Neh. 7:35) Eight members of this family were found to have married gentile women, whom they divorced. (Ezr. 10:31) Harim's son Malchijah was one of those who helped repair the walls of Jerusalem, including the Tower of the Furnaces. (Neh. 3:11) His seal was on the renewed covenant with God made by the Babylonian returnees. (Neh. 10:28) Head of a priestly family, with 1017 members, which returned with Zerubbabel. (Ezr. 2:39, Neh. 7:42) Five members of this family were found to have married gentile women, whom they divorced. (Ezr. 10:21) His seal was also on the renewed covenant. (Neh. 10:6) The head of his family at the time of the return was Adna. (Neh. 12:152)
-Rohgah Rohgah or Rohagah is a name which appears in 1 Chronicles 7:34, where Rohgah is named as one of the sons of Shamer (the vocalization found in v. 34) or Shomer (the vocalization found in v. 32), who is identified as the son of Heber, the son of Beriah, the son of the tribal patriarch Asher.
-Jeush Jeush is the name of four or five individuals mentioned in the Hebrew Bible.[292] Jeush son of Esau.[293] A variant manuscript reading, known as Ketiv, calls him Jeish.[292] Jeush son of Bilhan, son of Jediael, the son of Benjamin, mentioned in a genealogy which describes the people of the Tribe of Benjamin.[86] Jeush son of Eshek, who is mentioned in a genealogy of the Tribe of Benjamin.[118] According to the Encyclopaedia Biblica, this is likely a reference to the same person called Jeush son of Bilhan. The King James Version calls him Jehush. Jeush son of Shimei represented a division of Levites according to 1 Chronicles 23:10-11. Jeush son of king Rehoboam.[294]
-Jerijah Jerijah (sometimes Jeriah) is listed is one of the sons of Hebron in genealogical passages in 1 Chronicles 23:19, 24:23, 26:31.[286]
-Mishael This was the name of two biblical men. Mishael was a son of Uzziel of the house of Levi according to Exodus 6:22, born in Egypt. He was a nephew of Amram and a cousin of Aaron, Miriam, and Moses. He and Elzaphan were asked by Moses to carry away Nadab’s and Abihu’s bodies to a place outside the camp. (Leviticus 10:4) Mishael was one of the three Hebrew youths who were trained with Daniel in Babylon (Dan. 1:11, 19). He and his companions were cast into and miraculously delivered from the fiery furnace for refusing to worship the king's idol (3:13-30). Mishael's Babylonian name was Meshach. Misma, son of Simeon
-Hagabah Hagabah (also Hagaba, Graba, or Aggaba) is identified as the ancestor of a family of Nethinim, or temple assistants, who returned from the Babylonian captivity. They appear in a list with other returnees in Ezra 2:45, Nehemiah 7:48, and 1 Esdras 5:29.[141]
-Mattatha Mattatha is a figure who appears in the Genealogy of Jesus, in the version found in the Gospel of Luke.[13]
-Puah one of two midwives who saved the Hebrew boys. Exodus[155]
-Shechem Shechem was the name of two individuals mentioned in the Bible: A prince of Shechem who defiled Dinah according to Genesis 34 A son of Manasseh according to Numbers 26:31, Joshua 17:2, and 1 Chronicles 7:19.
-Jathniel Jathniel is a minor biblical figure who appears only in 1 Chronicles 26:2, in a list of Korahite porters.[261]
-Kolaiah Kolaiah ('voice of Jehovah') is the father of the false prophet Ahab (Jeremiah 29:21). It is also the name of an ancestor of Sallu that settled in Jerusalem after returning from the Babylonian exile (Nehemiah 11:7).[314]
-Ahisamach Ahisamach or Ahisamakh, also Ahis'amach (Hebrew: ×חיסמך 'brother of support'), of the tribe of Dan, was the father of Aholiab according to Exodus 31:6, Exodus 35:34, and Exodus 38:23.
-Malluch Heb. 'Reigned over, or reigning.' A Levite of the family of Merari 1 Chronicles 6:44 A priest who returned from Babylon (Neh. NIV),(Ezra 10:29),(Ezra 10:32)
-Jobab Jobab is the name of at least five men in the Hebrew Bible. A son of Joktan according to Genesis 10:29 and 1 Chronicles 1:23. Jobab ben Zerah, a King of Edom according to Genesis 36:33 and 1 Chronicles 1:44. King of Madon, one of the kings who fought against Israel in Joshua 11. A son of Shaharaim and Hodesh according to 1 Chronicles 8:9. A son of Elpaal according to 1 Chronicles 8:18.
-Amasa In 2 Chr 28:1-4, Amasa is the son of Hadlai, and one of the leaders of Ephraim (2 Chr 28:12) during the reign of the evil King Ahaz.
-Euodia Christian of the church in Philippi [54]
-Melea Fullness, the son of Menan and father of Eliakim, in the genealogy of our Lord (Luke 3:31).
-Pelaiah Pelaiah is the name of two biblical figures. In 1 Chronicles 3:23, a Pelaiah appears in a genealogy. He is listed as one of the sons of Elioenai, the son of Neariah, the son of Shemaiah, the son of Shechaniah. The other Pelaiah appears in Nehemiah (8:7; 10:10) as a Levite who helped to explain biblical law to the inhabitants of Yehud Medinata and signed a document against intermarriage between Jews and non-Jews.
-Hushim #2 One of the wives of Shaharaim I Chronicles[74]
-Joiarib See also: § Jehoiarib Joiarib ('God will contend') is the name of two biblical persons: Ancestor of Maaseiah the son of Barukh, who was one of those to resettle Jerusalem after the return from Babylonia. (Neh. 11:5) The head of a family of priests at the time of the return from Babylonia. (Neh. 12:6) He was one of the 'men of understanding' sent by Ezra to Iddo in order to procure men to minister in the Temple. (Ezr. 8:16) His son was Jedaiah, one of the priests to resettle Jerusalem. (Neh. 11:10) The head of the family at the time of Joiakim was Mattenai. (Neh. 12:19)
-Zebadiah Zebadiah ('Gift of God'; 'Jehovah has bestowed'; cf. Zebedee) may refer to: A son of Asahel, Joab's brother (1 Chronicles 27:7). A Levite who took part as one of the teachers in the system of national education instituted by Jehoshaphat (2 Chronicles 17:7-8). The son of Ishmael, 'the ruler of the house of Judah in all the king's matters' (2 Chronicles 19:8-11). A son of Beriah (1 Chronicles 8:15). A Korhite porter of the Lord's house (1 Chronicles 26:2). Three or four others of this name are also mentioned.
-Ben Deker Ben Dekar (Hebrew ×‘× ×“×§×¨ BeN DeQeR 'Son of Pick'), was one of King Solomon's twelve regional administrators; he was over Makaz, Shaalbim, Beth-shemesh, and Elon-beth-hanan. I Kings 4:9 (RSV).
-Damaris. Acts[41]
-Joshua the Bethshemite Joshua the Bethshemite was the owner of the field in which the Ark of the Covenant came to rest when the Philistines sent it away on a driverless ox-drawn cart. (I Samuel 6:14)
-Naamah #2 Mother of King Rehoboam. 'II Chronicles'[142]
-Gera Hebrew: ×’×¨× Ger'a In Genesis 46:21 Gera is the fourth of ten sons of Benjamin. Gera is also the name of the father of Shimei (2 Samuel 19:16) Gera is also the name of two of the sons of Bela (see above), making both nephews of the earlier Gera. (1 Chronicles 8:3,5) Gera is also the name of the father of Ehud, a 'Benjamite, a man left-handed' - Book of Judges, 3:15.
-Seba Seba was a son of Cush according to Genesis 10:7, 1 Chronicles 1:9.
-Ozem Ozem is a Hebrew name meaning strong, which applies to two people in the Bible. A brother of David, and the sixth son of Jesse (1 Chronicles 2:15). A son of Jerahmeel (1 Chronicles 2:25).
-Urijah Urijah (Hebrew: ×וריה uriyah 'God is my light') a priest in the time of King Ahaz of Judah, built an altar at the temple in Jerusalem on the Damascene model for Tiglathpileser, king of Assyria. II Kings 16:10-16
-Hasupha Hasupha (Hashupha in the King James Version) is the name of a clan or family of Nethinim (temple assistants) listed in Nehemiah 7:46 and Ezra 2:43.
-Shemaiah See List of people in the Hebrew Bible called Shemaiah
-Ikkesh Ikkesh the Tekoite was the father of Ira, one of King David's Warriors (2 Samuel 23:26, 1 Chronicles 11:28).
-Darda Darda (Hebrew דַּרְדַּע) was one of the exemplars of wisdom than whom Solomon was wiser.[91] In 1 Chronicles 2:6, his name is misspelled as 'Dara.'[92]
-Ahiram Ahiram was a son of Benjamin according to Numbers 26:38.
-Zaccur Zaccur of the house of Reuben was the father of Shammua, a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:4.
-Jaasu Jaasu (also called Jaasau, Jaasai) is a name which appears in a list of men alleged to have married foreign women in the time of Nehemiah.[240]
-Ithai See Ittai.
-Hannah A prophetess and citizen of Jerusalem. Mother of Samuel. I Samuel[64]
-Zabdi Zabdi, son of Zerah, of the Tribe of Judah, was the father of Carmi and the grandfather of Achan, according to Joshua 7:1. He was present at the Battle of Jericho.
-Maadai Maadai son of Bani is found in Ezra 10:34, in a list of men recorded as having married foreign women.
-Syntyche Christian of the church in Philippi mentioned with Euodia [187]
-Me-Zahab Mother of Matred, grandmother of Mehetabel.'Genesis, I Chronicles' [129][130]
-Mahalath #2 granddaughter of David and the first wife of King Rehoboam. II Chronicles[107]
-Rephaiah Rephaiah (Hebrew רְפָיָה 'the Lord has healed'), a descendant of David was the father of Arnan and the son of Jeshaiah.
-Arah Arah is the name of two minor biblical figures. The name may mean 'wayfarer.'[61] Arah the son of Ulla appears as a member of the Tribe of Asher in the part of the Books of Chronicles devoted to outlining the genealogy of the twelve Tribes of Israel.[62] In the Book of Ezra and the Book of Nehemiah, the 'sons of Arah' are a group listed among the returnees to Jerusalem in the time of Nehemiah.[63] Shechaniah, a 'son of Shecaniah,' was the father-in law of Tobiah the Ammonite.[64]
-Ahuzzam Ahuzzam or Ahuzam is the name of one of the sons of 'Asshur, the father of Tekoa,' in a genealogy describing the desceandants of the Tribe of Judah.[44] He is mentioned only in 1 Chronicles 4:6.[45]
-Nephish See Naphish.
-Chalcol Chalcol the son of Darda (Hebrew כלכל kalkol - the same consonants with different vowel points (kilkayl) mean 'maintain') is listed in 1 Kings 4:31 as an example of a very wise man who is, nevertheless, not as wise as Solomon. Another person with the same Hebrew name (though spelled 'Calcol' in the King James Version) is listed in 1 Chronicles as the son of Zerah, the son of Judah (son of Jacob).[83]
-Jephunneh Jephunneh (×™Ö°×¤Ö»× Ö¶Ö¼×”) is a biblical name which means 'for whom a way is prepared', and was the name of two biblical figures: A descendant of Judah, and father of Kenaz and Caleb the spy or scout, who appears to have belonged to an Edomitish tribe called Kenezites, from Kenaz their founder. See (Numbers 13:6 etc.; Num. 32:12 etc.; Josh 14:14 etc.; 1 Chr 4:15). A descendant of Asher, eldest of the three sons of Jether (1 Chronicles 7:38).
-Admin In some translations of Luke 3:33, Admin is an ancestor of Jesus, the father of Aminadab and son of Arni.[30]
-Maaziah Head of the twenty-fourth priestly course in David's reign. 1 Chronicles 24:18 Also, A priest Neh. 10:8
-Genubath Genubath (Hebrew: ×’× ×‘×ª genubat 'Stolen' [125]) is mentioned in I Kings 11:20 as the son born to Hadad the Edomite and the sister of Queen Tahpenes, Pharaoh's wife.
-Diblaim Diblaim (Hebrew ×“Ö´Ö¼×‘Ö°×œÖ¸Ö«×™Ö´× 'cakes of pressed figs') was the mother of the prophet Hosea's wife, Gomer. Her name means 'doubled cakes'. (Hosea 1:3)
-Shuni Shuni was a son of Gad according to Genesis 46:16 and Numbers 26:15. He was one of the 70 persons to migrate to Egypt with Jacob.
-Elnaam Elnaam, according to 1 Chronicles 11:46, was the father of Jeribai and Joshaviah, two of David's Mighty Warriors.
-Shinab Shinab is the king of Admah in Genesis 14 who joins other Canaanite city kings in rebelling against Chedorlaomer.
-Henadad Henadad is a biblical name which appears only in Ezra-Nehemiah. In a passage which describes the rebuilding of the wall of Jerusalem, two 'sons of Henadad', Bavai and Binnui, are named as taking responsibility for portions of the wall.[175] Binnui reappears later, where he is described as a Levite and as one of the signatories of the covenant between Ezra, God, and the people of Judah.[176] The 'sons of Henadad,' though without any specific individuals named, are mentioned in also in Ezra 3:9, a 'difficult passage'.[177]
-Shaaph Shaaph is a name which appears in the second chapter of 1 Chronicles. In one translation, these verses read as follows: 'And the sons of Jahdai: Regem, and Jotham, and Geshan, and Pelet, and Ephah, and Shaaph. Maacah, Caleb's concubine, bore Sheber and Tirhanah. And [the wife of] Shaaph the father of Madmannah bore Sheva the father of Machbenah and the father of Gibea. And the daughter of Caleb was Achsah' (1 Chronicles 2:47-49). The words [the wife of] do not occur in the Hebrew text, which reads literally, as Sara Japhet translates it, 'And Shaaph the father of Madmannah bore Sheva . . .' but with a feminine form (watteled) of the verb 'bore,' rather than the expected masculine form wayyoled.[39] Japhet outlines several possibilities as to how the text may originally have read.[39]
-Melzar Probably a Persian word meaning master of wine, i.e., chief butler; the title of an officer at the Babylonian court Daniel 1:11,Daniel 1:16 who had charge of the diet of the Hebrew youths.
-Ishvah Ishvah (KJV Ishuah and Isuah) was one of the sons of Asher according to Genesis 46:17 and 1 Chronicles 7:30, although he is missing from the list of the sons of Asher found in Numbers 26:44.[224]
-Miriam #1 Moses' sister. Exodus, Numbers, Deuteronomy, I Chronicles[135][136][137][138][139]
-Keziah #2 Second daughter of Job. Job[83]
-Miriam #2 woman of Judah. I Chronicles[140]
-Beno Beno was the son of Merari and from Jaaziah 1 Chronicles 24:26-27.
-Haahashtari Haahashtari or Ahashtari was one of the sons of Naarah, one of the two wives of Asshur (1 Chronicles 4:6). Because the name is used to refer to a family of Judahites who descend from Judah via Ashhur, Thomas Kelly Cheyne believed that the name 'Haahashtari' arose from a confusion between Ha-Ashhuri ('the Ashhurite') with the obscure term ahashtranim which appears in Esther 8:10.[131]
-Shimi Shimi was a son of Gershon of the house of Levi according to Exodus 6:17. He was born in Egypt.
-Hadlai Hadlai is mentioned in 2 Chronicles 28:12 as an Ephraimite, and the father of Amasa. In manuscripts of the Greek Septuagint, his name is given as Choab, Addi, or Adli.[139]
-Shelomith Shelomith was a daughter of Dibri of the house of Dan, according to Leviticus 24:11. She was married to an Egyptian and her son (unnamed) was stoned to death by the people of Israel for blasphemy, following Moses' issue of a ruling[42] on the penalty to be applied for blasphemy.
-Jediael There are three individuals in the Hebrew Bible named Jediael.[263] Jediael son of Shimri is listed as one of David's warriors in 1 Chronicles 11:45. Jediael, a man from the Tribe of Manasseh, appears in a list of warriors said to have deserted David when he went to Ziklag.[264] Jediael son of Meshelemiah appears in a list of Korahite porters in the time of David.[265]
-Ibsam According to Chronicles, Ibsam was the son of Tola, who in turn was the son of Issachar.[198] He is called Jibsam in the King James Version.[199]
-Naggai Naggai (King James Version spelling Nagge) is the name of a figure found in the genealogy of Jesus according to the Gospel of Luke.[21][22]
-Miniamin See Mijamin.
-Minjamin See Minjamin.
-Alvan In Genesis 36:23, Alvan is the eldest son of Shobal and a descendant of Seir the Horite. In 1 Chronicles 1:40 he is called Alian.
-Ephrath Second wife of Caleb (the spy) I Chronicles[51]
-Jael Heroine who killed Sisera to deliver Israel from the troops of king Jabin. She was the wife of Heber the Kenite. Judges[76]
-Shobal Shobal was a Horite chief in the hill country of Seir during the days of Esau. He was a son of Seir the Horite, and his sons were Alvas, Manahath, Ebal, Shepho and Onam. He is mentioned in Genesis 36:20-29.
-Shammua There are four individuals by the name of Shammua in the Hebrew Bible:[41] Shammua, the son of Zaccur of the house of Reuben, was a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:4. A son of David, mentioned in 2 Samuel 5:14 and 1 Chronicles 14:4. A Levite in the time of Nehemiah (11:17). A Levite in the time of Nehemiah (12:18).
-Ahlai #1 daughter of Sheshan. I Chronicles[17]
-Ahlai #2 mother of Zabad (in David's guard)I Chronicles[18]
-Shobab Shobab is the name of two figures in the Hebrew Bible. Shobab was one of the children born to King David after he took up residence in Jerusalem (2 Samuel 5:14), whose mother is named in 1 Chronicles 3:5 as Bathshua or Bathsheba, the daughter of Ammiel.[45] In Brenton's Septuagint Translation, his name is translated as 'Sobab' and his mother's name is given as 'Bersabee'.[46] Each reference to him mentions him briefly, in a list along with at least three other sons of David born in Jerusalem (2 Samuel 5:14; 1 Chronicles 3:5, 14:4). Shobab is listed 1 Chronicles 2:18 as one of the children of Caleb, son of Hezron (not to be confused with the more famous Caleb son of Jephunneh).
-Jasiel See Jaasiel.
-Ephron Ephron the Hittite, son of Zohar, lived in Mamre among the children of Heth. He was the owner of the property that included the Cave of Machpelah, which he sold to Abraham for four hundred shekels of silver. (Genesis 23:8-17)
-Elishaphat Elishaphat, son of Zichri, was one of the 'captains of hundreds' associated with Jehoiada in restoring king Jehoash to the throne 2 Chronicles 23:1.
-Noadiah prophetess. Nehemiah[146]
-Tabitha (Acts 9:36) from Joppa, Tabitha was always doing good and helping the poor. AKA 'Dorcas'
-Sodi Sodi of the house of Zebulun was the father of Gaddiel, a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:10.
-Jogli Jogli was the father of Bukki, a prince of the Tribe of Dan. (Num. 34:22)
-Taphath Taphath (Hebrew טפת, 'Drop') was a daughter of Solomon and wife of one of her father's twelve regional administrators, the son of Abinadab (First Kings 4:11).
-Imna Imna is a biblical name which appears only in 1 Chronicles 7:35, in a genealogy of the Tribe of Asher.[205]
-Cozbi A Midianite princess who was killed by Phinehas (grandson of Aaron) because her evil influence was seen as the source of a plague among the Israelites. Numbers[40]
-Tamar #1 daughter-in-law of Judah, as well as the mother of two of his children, the twins Zerah and Perez. Genesis[188]
-Tamar #2 daughter of King David, and sister of Absalom. Her mother was Maacah, daughter of Talmai, king of Geshur. II Samuel[189]
-Elisheba #2 Wife of Aaron. Exodus[49]
-Miamin See Mijamin.
-Jehoaddan (or Jehoaddin) II Kings, II Chronicles[80][81]
-Eliathah Eliathah is the name given in 1 Chronicles 25:4 to one of the 'fourteen sons' of Heman. According to 25:27, he gave his name to one of the twenty-four classes of temple singers.
-Jehoaddah Joehoaddah (or Jehoadah, Jarah) was one of the descendants of King Saul, according to 1 Chronicles 8:33-36. In 1 Chronicles 9:42, which contains a copy of the same genealogy of Saul, his name is given as 'Jarah.'[271]
-Rahab of Jericho. Joshua, Matthew, Hebrews, James[161][162][163][164]
-Nekoda Nekoda was the ancestor of 652 Jews who returned from Babylonia with Ezra, but were declared ineligible to serve as Kohanim (priests) because they could not prove that their ancestors had been Kohanim. This is recounted in Ezra 2:48,60 and in Nehemiah 7:50, 62, where the number of men is given as 642.
-Nereus Nereus was a Christian mentioned with his unnamed sister in Romans 16:15 with other saints to whom Paul the Apostle sent greetings and salutations.
-Elisheba Elisheba ('God is my oath', cognate to the name Elizabeth) is the wife of Aaron and sister-in-law of Moses. Her sons were Nadab, Abihu, Eleazer and Ithamar. (Exodus 6:23).
-Pelaliah Pelaliah (Hebrew PÄ•lalyÄh) is a figure mentioned only indirectly and in passing in Nehemiah 11:12, which lists a descendant of his as a priestly leader in Jerusalem. The descendant is specified as 'Adaiah son of Jeroham son of Pelaliah son of Amzi son of Zechariah son of Pashhur son of Malchiah.'
-Shearjashub Shearjashub, the first-mentioned son of Isaiah according to Isaiah 7:3. His name means 'the remnant shall return' and was prophetic; offering hope to the people of Israel, that although they were going to be sent into exile, and their temple destroyed, God remained faithful and would deliver 'a remnant' from Babylon and bring them back to their land.
-Matri Matri, of the Tribe of Benjamin, was an ancestor of Saul according to I Samuel 10:21. Matri's clan, or the family of the Matrites, was chosen, and ,from them, Saul the son of Kish was chosen to be king. The family of the Matrites is nowhere else mentioned in the Hebrew Bible; the conjecture, therefore, is that Matri is probably a corruption of Bikri, i.e. a descendant of Becher (Genesis 46:21).[12]
-Geber Geber (Hebrew: גבר, geber), son of Uri, was one of King Solomon's regional administrators; his territory was Gilead. (First Kings 4:19)
-Hermogenes A Hermogenes is briefly mentioned in 2 Timothy 1:15, where he, along with someone named Phygelus, are described as having 'turned away' from Paul the Apostle. Nothing more is known about Hermogenes.[178]
-Mallothi Heb. 'My fulness', a Kohathite Levite, one of the sons of Heman the Levite (1 Chronicles 25:4), and chief of the nineteenth division of the temple musicians 1 Chronicles 25:26
-Hogla (or Hoglah) One of the five daughters of Zelophehad who fought and won the right to inherit their deceased father's property. Numbers, Joshua[70][71]
-Hadadezer According to I Kings 11:23, Hadadezer (Hebrew: הדדעזר hadad`ezer 'Hadad helps'[138]) was king of Zobah.
-Jehoshaphat Jehoshaphat (Hebrew: יהושפט, yehoshaphat, God Judges) son of Paruah, was one of King Solomon's twelve regional administrators, his jurisdiction was Issachar. (I Kings 4:17) Jehosphaphat, son of Ahilud, was King Solomon's recorder. (I Kings 4:3)
-Rehum Rehum is the name of four or five biblical figures.[32] A Rehum is mentioned in Ezra 2:2, who is called Nehum in Nehemiah 7:7. He appears in passing, in two copies of a list of people said to have come from Persia to Yehud Medinata under the leadership of Nehemiah. He may be the same individual mentioned in Nehemiah 12:3. A Rehum is mentioned in Nehemiah 12:3, where he is listed as part of a group of priests associated with Zerubbabel. Rehum son of Bani, a Levite, appears in a list of people who contributed to building Nehemiah's wall in Nehemiah 3:17. Rehum, a member of a group of priests associated with Zerubbabel according to Nehemiah 12:3. Rehum was an official, according to Ezra 4:8-23, who along with collaborators opposed the Jewish attempt to rebuild Jerusalem.
-Idbash Idbash, according to 1 Chronicles 4:3, was one of the sons of Etham, a figure who appears in the Chronicler's genealogy of the Tribe of Judah.
-Zeror Zeror, son of Bechorath, of the tribe of Benjamin, was the great-grandfather of King Saul and of his commander Abner. According to Saul, his family was the least of the tribe of Benjamin. (1 Samuel 9)
-Nemuel Nemuel was the name of two individuals mentioned in the Bible: The son of Eliab of the Tribe of Reuben according to Numbers 26:9. Jemuel, a son of Simeon.
-Bigtha Bigtha is one of the eunuchs who served King Xerxes in Esther 1:10.
-Abida Abida or Abidah appears twice in the Bible,[13] as a son of Midian. Nothing further is said about him in the Bible.[14]
-Moab Moab was the son of Lot and his eldest daughter. He became the father of the Moabites (see Genesis 19:36-37).
-Mary #1 Mother of Jesus. Matthew, Mark, Luke, John, Acts, Galatians[111][112][113][114][115][116]
-Mary #3 the sister of Martha. Luke, John[118]
-Mary #2 the mother of James and Joses (or Joseph). Matthew[117]
-Mary #5 who was greeted by Paul. Romans[120]
-Mary #4 the wife of Cleophas. John[119]
-Mary #6 Magdalene
-Shelumiel Shelumiel (Hebrew: שלמי×ל) was a son of Zurishaddai, a prince of the tribe of Simeon and one of the leaders of the tribes of Israel, according to Numbers 1:6.
-Obadiah 'Obadiah' was a descendant of David, father of Sheconiah, and son of Arnan
-Sabtah Sabtah was a son of Cush according to Genesis 10:7, 1 Chronicles 1:9.
-Antothijah Antothijah or Anthothijah is a name which appears only once in the Hebrew Bible, in a genealogical section listing descendants of Benjamin.[57][58] It is most likely an adjective used to describe a female person from the town of Anathoth.[58] Manuscripts of the Greek Septuagint give the name as Anothaith, Anathothia, Athein, or Anathotha.[58]
-Ozni See Ezbon above.
-Joshaviah Joshaviah son of Elnaam is a biblical figure who appears only in 1 Chronicles 11:46, in a listing of David's Mighty Warriors.[303]
-Elihoreph Elihoreph (Hebrew ×ליחרף) was a scribe in King Solomon's court. He was a son of Shisha and brother of Ahiah. (I Kings: 4:3) The name means ''my God repays,' or 'my God is the giver of the autumn harvest,''.[105]
-Machi Machi of the Tribe of Gad was the father of Geuel, a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:15.
-Zephaniah Zephaniah (Hebrew ×¦×¤× ×™×”, pronounced TsePhNiYaH, which means 'My God conceals me', was the name of at least two people in the Bible: Zephaniah the prophet (q.v.) Zephaniah the son of Maaseiah the priest in Jeremiah 29:25. A member of the deputation sent by King Zedekiah to Jeremiah (Jeremiah 21:1; 37:3). 'He is probably the same Zephaniah who is called 'the second priest' in 52:24 ... and was among those executed after the capture of Jerusalem in 587 B.C. In the present situation he is overseer of the temple (vs. 26), occupying the position which had been held earlier by Pashur, who had put Jeremiah in stocks...' [54]
-Heber Heber or Chéver (Hebrew: חֶבֶר‎ / חָבֶר‎, Modern Ḥéver / Ḥáver Tiberian Ḥéḇer / ḤÄḇer ; 'friend', 'connected') is the grandson of the patriarch Asher mentioned at Genesis 46:17 and in Numbers 26:45. Heber probably should not be confused with the Eber who was Abraham's ancestor.
-Hotham Hotham is the name for two individuals found in the BIble.[191] A Hotham appears in a genealogy of the Tribe of Asher in 1 Chronicles 7:32, but this individual is referred to as 'Helem' in verse 35.[191] Another Hotham, though the KJV calls him Hothan, can be found in 1 Chronicles 11:44, where his sons Shama and Jeiel are listed among David's Mighty Warriors. This second Hotham is called an Aroerite.[191]
-Shimron Shimron was a son of Issachar according to Genesis 46:13, Numbers 26:24 and 1 Chronicles 7:1. He was one of the 70 souls to migrate to Egypt with Jacob.
-Jalon Jalon was one of four sons of Ezrah, and the uncle of Miriam, Shammai and Ishbah (father of Eshtemoa). (1 Chr. 4:17)
-Ner Ner (Hebrew: 'Candle') was an uncle of Saul and the father of Abner according to I Samuel 14:50.
-Shemer Shemer (Hebrew: שמר Shemer 'guardian') was the man from whom Omri, King of Israel, bought Samaria.[43]
-Dinah Daughter of Jacob, one of the patriarchs of the Israelites and Leah, his first wife. Genesis[45]
-Taphath #2 daughter of Solomon[191]
-Phoebe A deaconess of the church of Cenchrea. Romans[150]
-Junia or Junias Regarded highly by St. Paul in Romans. May or may not have been a woman.[95]
-Kallai Kallai is named as ancestral head of the priestly house of Sallai in the time of Jehoiakim, according to Nehemiah 12:20.
-Jaaziel Jaaziel is the name of a Levite musician who appears in 1 Chronicles 15:18. He reappears as 'Aziel' in 15:20.[242]
-Meres Meres is listed in Esther 1:14 as one of seven officials in the service of Ahasuerus.
-Mahath Hebrew for 'Grasping' A Kohathite Levite, father of Elkanah 1 Chronicles 6:35 Another Kohathite Levite, of the time of Hezekiah 2 Chronicles 29:12
-Gatam Gatam is a name which appears in Genesis and Chronicles in a genealogy of the Edomites. In Genesis 36:11 and 1 Chronicles 1:36, Gatam is described the 'son' of Eliphaz, the son of Esau (who is according to the Bible the forefather of the Edomites). In the passages which describe Gatam as a 'son' of Eliphaz, he is listed alongside his 'brothers': Teman, Omar, Zepho, and Kenaz according to Genesis; a similar but slightly larger list of brothers in Chronicles (Chronicles includes Amalek as a brother of Gatam). However, in Genesis 36:16, Gatam and Amalek (along with a previously unmentioned Korah) are described not as individual sons but as 'clans' of Eliphaz.[122]
-Elizur Elizur was a son of Shedeur and a prince of the House of Reuben according to Numbers 1:5, and one of the leaders of the tribes of Israel. He appears only in the Book of Numbers, in five verses (1:5; 2:10; 7:30, 35; 10:18).[107]
-Ishod See Ishhod.
-Jeshaiah Jeshaiah may refer to multiple figures in the Bible: A descendant of David, the father of Rephaiah, and the son of Hananiah in 1 Chronicles 3:21. One of eight sons of Jeduthun in 1 Chronicles 25:3. For the man in 1 Chronicles 24 and 26 who is sometimes called Jeshaiah, see Jesiah.
-Jekameam Jekameam son of Hebron is mentioned in passing in two genealogical passages.[280]
-Eliphal Eliphal son of Ur is listed as one of David's Mighty Warriors in 1 Chronicles 11:35. In the corresponding place in Samuel's version of the list (2 Samuel 23:34), he is called 'Eliphelet son of Ahasbai the Maachathite.' According to the Encyclopaedia Biblica, the name 'Eliphal' (Hebrew ʾlypl ) is copyist's error for 'Eliphelet' ( ʾlyplt ) caused by dropping the final letter in the name.[101][102]
-Peresh According to 1 Chronicles 7:16, Peresh was the son of Machir, the son of Manasseh.
-Nedabiah Nedabiah, according to 1 Chronicles 3:18, was one of the sons of king Jeconiah.
-Iscah Main article: Iscah Iscah or Jesca (Jessica) was a daughter of Haran, sister of Lot and Milcah according to Genesis 11:29.
-Priscilla wife of Aquila, and missionary partner to Paul the Apostle. Acts, Romans, I Corinthians, II Timothy[151][152][153][154]
-Aedias Aedias, a descendant of Ela, appears in 1 Esdras 9:27 as one of the men found to have married foreign women. 1 Esdras appears in some Christian Bibles, but not in the Bibles used by Jews and most Protestants. In the parallel verse in the Book of Ezra, 10:26, the name 'Elijah' is found.[36]
-Vaizatha Vaizatha (or Vajezatha; Hebrew: וַיְזָתָ×) is one of the ten sons of Persian vizier Haman, mentioned in Esther 9:9. Haman had planned to kill all the Jews living under the reign of King Ahasuerus, but his plot was foiled. In their defence, the Jews killed 500 men in the citadel of Susa, as well as Vaizatha and his nine brothers: this event is remembered in the Jewish festival Purim. Walther Hinz has proposed that the name is a rendering of an Old Iranian name, VahyazzÄta, which itself is derived from Vahyaz-dÄta ('given from the best one'), as found in Aramaic, Elamite, and Akkadian sources.[47]
-Parmashta Parmashta appears briefly in Esther 9:9, where he is listed as one of the ten sons of Haman, who is the primary antagonist of the Book of Esther because of his desire to wipe out the Jews.
-Ahinoam #2 one of King David's wives, mother of Amnon. I Samuel; II Samuel; I Chronicles[14][15][16]
-Ginath Ginath is a name which is mentioned only in passing in a narrative describing the struggle for kingship between Omri and Tibni.[126] Tibni is referred to in 1 Kings 16:21 and 22 as 'son of Ginath,' which taken literally, could be read as implying that a person named Ginath was Tibni's father.[126] However, the Encyclopaedia Biblica suggests that the term 'Ginath' is a place-name or clan-name, so that 'Tibni son of Ginath' has the meaning 'Tibni of Ginath.'[126]
-Ishmerai Ishmerai is a biblical figure mentioned only in 1 Chronicles 8:18, where he is called 'the son of Elpaal' in a genealogy of the Tribe of Benjamin.[218] He may be the same character as the 'Shemer' or 'Shemed' mentioned in 1 Chronicles 8:12.[218]
-Ahinoam #1 wife of King Saul, mother of Michal (wife of King David) I Samuel[13]
-Gaddi Gaddi, the son of Susi of the House of Manasseh, was a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:11.
-Naarah wife of Asher, tribe of Judah. I Chronicles[143]
-Peleth Peleth, of the Tribe of Reuben, was the father of On, a participant in Korah's rebellion against Moses according to Numbers 16:1.
-Malchi-shua Heb. 'King of help', one of the four sons of Saul (1 Chronicles 8:33). He perished along with his father and brothers in the battle of Gilboa (1 Samuel 31:2).
-Hodiah's wife I Chronicles[69]
-Regem Regem is named in 1 Chronicles 2:47 as one of the sons of Jahdai, a figure who appears in a genealogy associated with Caleb.
-Aharhel In 1 Chronicles 4:8, Aharhel (Hebrew ×ֲחַרְחֵל 'behind the rampart') is the son of Harum of the tribe of Judah.
-Zabud Zabud (Hebrew - זבוד, zÄbud, meaning “endowed.â€[48]) was a priest and friend of King Solomon, according to 1 Kings 4:5. He is described as the 'son of Nathan,' but it is unclear whether this is Nathan the prophet or Nathan the son of David.[49] As a 'friend' of the king, he probably served the function of a counselor.[49]
-Hamul Hamul was a son of Pharez of the Tribe of Judah according to Genesis 46:12 and Numbers 26:21. He was one of the 70 souls to migrate to Egypt with Jacob.
-Jesimiel Jesimiel appears in a list of names of Simeonites. According to Chronicles these Simeonites took pasture-land from descendants of Ham and the Meunim during the time of king Hezekiah.[290] According to Thomas Kelly Cheyne, the name is a corruption of Maaseel.[291]
-Ajah In Genesis 36:24 and 1 Chronicles 1:40, Ajah [××™×”] is a son of Zibeon. Ajah means hawk. Alternative spelling: Aiah.
-Mahlah Mahlah (“infirmity,†“a harpâ€, or “pardonâ€) is the name of two biblical persons: One of the daughters of Zelophehad, who with her four sisters brought a claim regarding inheritance before Moses. (Numbers 26:33, 27:1–11, 36; Jo. 17:3–6 A child of Gilead's sister Hammolecheth and great-granddaughter of Manasseh. She had two siblings, Ishhod and Abiezer. (1 Chr. 7:18–6
-Ishbah For the 'Ishbah father of Eshtemoa' mentioned in 1 Chronicles, see List of minor biblical tribes § Ishbah.
-Lydia of Thyatira one of the first to convert to Christianity. Acts[103]
-Laadah Laadah or Ladah was a son of Shelah and a grandson of Judah. His son was Mareshah. (1 Chr. 4:21)
-Hephziba Wife of King Hezekiah and mother of Manasseh who undid his father's good works. II Kings[67]
-Gideoni Gideoni (Hebrew: ×’Ö´Ö¼×“Ö°×¢Ö¹× Ö´×™) was a member of the tribe of Benjamin according to Numbers 1:11. He was the father of Abidan, a tribal chief. He is mentioned five times in the Book of Numbers, with each reference stating his relation to Abidan (Num 1:11, Num 2:22, Num 7:60, Num 7:65, Num 10:24.)[127] His name is variously understood as meaning 'one with a disabled hand,' 'a youth,' or 'one who cuts down trees.'[127]
-Ammizabad Ammizabad was the son of Benaiah, who was the third and chief captain of the host under David (1 Chronicles 27:6).
-Assir Assir was a son of Korah of the house of Levi according to Exodus 6:24, born in Egypt. It was also the firstborn son of Jehoiachin, King of Judah.
-Ahilud Ahilud is the father of Jehoshaphat, who serves as court recorder to David (2 Samuel 8:16) and Solomon (1 Kings 4:3). In 1 Kings 4:12, Ahilud is the father of Baana, an official in Solomon's court sent to gather provisions in Taanach and Megiddo, and Beth Shan.
-Matthanias Matthanias is the name of two individuals in 1 Esdras, one each mentioned in 1 Esdras 9:27 and 9:31. In both passages, the parallel text in Ezra 10:26 and 10:30 contains the name Mattaniah.[15]
-Shelomit #1 mother of blasphemer. Leviticus[184]
-Basemath Hebrew: Sweet-smelling or Sweet-smile Basemath, wife of Esau, and daughter of Elon the Hittite (Genesis 26:34). She is thought to be identical to or a sister to Adah who is mentioned in Genesis 36.[78] Basemath, another wife of Esau, daughter of Ishmael, sister to Nebajoth and mother of Reuel (Genesis 36:3). She is thought by some scholars to be the same as Mahalath of Genesis 28. Basemath, the daughter of Solomon; a wife of Ahimaaz. (1Kings 4:15)
-Gemariah Gemariah (Hebrew: גמריה) is the name of at least two biblical characters: Gemariah son of Shaphan in chapter 36 of Jeremiah. His own son Micaiah hears Jeremiah's secretary Baruch read Jeremiah's prophecies against the nation, and reports to a meeting of the court officials, including his father, nearby. This leads to the scroll being read before king Jehoiakim, who cuts it up and burns it despite the protestations of Gemariah and Elnathan ben Achbor.[124] Gemariah son of Hilkiah, one of the envoys whom King Zedekiah sent to Babylonia (Jeremiah 29:3) Nothing else is known of him; he was hardly the brother of Jeremiah, whose father was also named Hilkiah.[96]
-Shelomit #2 daughter of Zerubbabel, sister of Meshullam and Hananiah. I Chronicles[185]
-Hareph Hareph, according to 1 Chronicles 2:51, was a descendant of Caleb and the father of Beth-gader.[152] The name 'Hareph' in this case may refer to a group of people otherwise referred to by the term Hariphite.[153]
-Pethuel Pethuel, the father of Joel, in Joel 1:1.
-Areli Areli was a son of Gad according to Genesis 46:16 and Numbers 26:17. He was one of the 70 souls to migrate to Egypt with Jacob.
-Meraioth 'Rebellions', Father of Amariah, a priest of the line of Eleazar (1 Chronicles 6:6-7), (1 Chronicles 6:52). It is uncertain if he ever was the high priest. A priest who went to Jerusalem with Zerubbabel (Nehemiah 12:15). He is called Meremoth in Neh 12:3.
-Chuza Chuza was the manager of Herod Antipas' household. His wife, Joanna, was a follower of Jesus (see Luke 8:1-3).
-Neariah 'Neariah' is the name of two biblical individuals. Neariah the son of Shemaiah, was a descendant of David, and father of Elionenai (1 Chronicles 3:22). The other Neariah was, according to Chronicles, a leader in the Tribe of Simeon (1 Chronicles 4:42).
-Jecholiah (or Jecoliah) Wife of Amaziah (King of Judah) and mother of Uzziah. II Kings, II Chronicles[77][78]
-Haran Haran, or Aran (Hebrew הָרָן) refers to three minor biblical people in the Hebrew Bible: Haran, son of Terah, from Ur of the Chaldees. He fathered Lot, Milcah and Iscah. (Genesis 11:27-29) Haran, son of Caleb, a descendant of Jacob, and Ephah his mother. Father of 1.Gazez, and brother of 2.Gazez. (1Chronicles 2:46) Haran, son of Shimei, a Levite who lived in the age of King David that had some important religious or political role. (1 Chronicles 23:1-9)
-Hezron Hezron or Hetzron (Hebrew: חֶצְרוֹן, Modern Ḥetsron, Tiberian Ḥeṣrôn; 'Enclosed' [181]) is the name of two men in Genesis. In Genesis 46:9, Hezron is a son of Reuben and the founder of the Hezronites. In Genesis 46:12, Hezron is grandson of Judah and the son of Pharez.
-Imri Imri is the name of two individuals mentioned in the Hebrew Bible.[207] An Imri is mentioned in passing in the ancestry of a man named Uthai, who according to 1 Chronicles 9:4 lived in Jerusalem after the return from the Babylonian captivity. A man named 'Zakkur son of Imri' is recorded as taking responsibility for a section of the wall in the project of rebuilding the wall of Jerusalem, according to Nehemiah 3:2.
-Meraiah 'Resistance', a chief priest, a contemporary of the high priest Joiakim (Neh 12:12).
-Haggi Haggi was a son of Gad according to Genesis 46:16 and Numbers 26:15. He was one of the 70 persons to migrate to Egypt with Jacob.
-Nahath Nahath is the name of three figures who appear in the Hebrew Bible.[24] Nahath, son of Reuel, son of Esau appears in a genealogy of the Edomites, found in Genesis 36:13 and repeated in 1 Chronicles 1:37. According to the Encyclopaedia Biblica', this Nahath is probably the same figure as the Naham of 1 Chronicles 4:19 and the Naam of 1 Chronicles 4:15.[24] A Nahath appears in the ancestry of Samuel according to 1 Chronicles 6:26 (verse 11 in some Bibles). A Nahath appears in a list of Levite supervisors in the time of Hezekiah, in 2 Chronicles 31:13
-Reumah #2 concubine of Abraham's brother Nahor. Genesis[167]
-Zuriel Zuriel ('My Rock is God') was the son of Abihail (Numbers 3:35). A Levite, Zuriel was chief prince of the Merarites at the time of the Exodus.
-Admatha Mentioned only in Esther 1:14, Admatha is an advisor to Ahasuerus of Persia.[29] According to one theory, the verse has suffered from scribal error, and as it originally stood Admatha was instead Hamdatha, not an adviser to Ahaseurus but the father of Haman.[29]
-Rachel second wife of Jacob, and sister of Leah. Genesis, I Samuel, Jeremiah, Matthew[157][158][159][160]
-Jehozabad Jehozabad (Hebrew: יהוזבד, yehozabad) is the name of three figures in the Hebrew Bible.[273] Jehozabad son of Shomer was one of the assassinators of King Joash of Judah. II Kings 12:21. 'This person is called Zabad, in 2 Chron. xxiv.26...' [274] Jehozabad, according 2 Chronicles 17:18, was a leader of 180,000 Benjamite warriors in the time of king Jehoshaphat. Jehozabad is listed as one of the sons of Obed-edom according to 1 Chronicles 26:4.
-Hakkatan Hakkatan (also Acatan, Akatan), meaning 'the small one,' is listed as the father of Johanan, a leader of the descendants of Azgad in Ezra 8:12 and 1 Esdras 8:38.[142] Other than these two verses, the name Hakkatan appears nowhere in the Bible.[142]
-Elmadam Elmadam or Elmodam is the name of an ancestor of Jesus, according to the genealogy found in the Gospel of Luke.[108] The Peshitta calls him Elmodad, but the Encyclopaedia Biblica suggests the reading 'Elmatham,' a form of the name Elnathan.[109]
-Raddai Raddai, according to 1 Chronicles 2:14, was one of the brother of King David.
-Beriah Beriah is the name of four different biblical individuals: One of Asher's four sons, and father of Heber and Malchiel.[80] A son of Ephraim (1 Chr. 7:20-23), born after the killing of Ephraim's sons Ezer and Elead, and so called by his father 'because disaster had befallen his house.'[81] A Benjamite, son of Elpaal. He and his brother Shema expelled the Gittites, and were patriarchs to the inhabitants of Ajalon. His sons were Michael, Ishpah and Joha. (1 Chr. 8:13) A Levite, the son of Shimei. He was jointly patriarch of a clan with his brother Jeush. (1 Chr. 23:10-11)
-Huzzab Huzzab is either a name or a word which appears in Nahum 2:7 (verse 8 in some Bibles). In a passage in which Nahum is predicting the fall of Nineveh, the prophet says, 'Huzzab shall be led away captive' in the King James Version. However, a number of more contemporary versions since the late nineteenth century have interpreted the word as a verb, meaning 'and it has been decreed.'[192][193]
-Naboth Naboth was a minor figure known for owning a vineyard that king Ahab wished to have for himself. When Naboth was unwilling to give up the vineyard, Ahab's wife Jezebel instigated a plot to have Naboth killed. See 1 Kings 21.
-Molid (Hebrew מוֹלִיד 'to have children') A son of Abishur of the tribe of Judah (1 Chronicles 2:29).
-Tahan Tahan was a son of Ephraim according to Numbers 26:35 and 1 Chronicles 7:25.
-Joash This entry about the four minor biblical characters named Joash. For the kings named Joash or Jehoash, see Jehoash of Israel and Jehoash of Judah. Joash, an abbreviated name of Jehoash, is the name of several figures in the Hebrew Bible. Joash, an Abiezrite of the Tribe of Manasseh, was the father of Gideon according to Judges 6 - 8.[295] His family was poor and lived in Ophrah. After Gideon tore down the altar of Baal and cut down the grove, the men of Ophrah sought to kill Gideon. Joash stood against them, saying, 'He that will plead for [Baal], let him be put to death whilst it is yet morning: if he be a god, let him plead for himself, because one hath cast down his altar.' A Joash is described as 'the kings son' in the time of Ahab. According to Stanley Arthur Cook, it is uncertain whether he was the son of king Ahab, or whether 'king's son' was a title used high officers.[296] Joash is described as one of the sons of Shelah son of Judah (son of Jacob) in a genealogy of the Tribe of Judah.[297] A Joash is named as one of the Benjamite warriors to came to the aid of David when he went to Ziklag.[298]
-Japhia Japhia was the king of Lachish, one of the five kings of the Amorites whose battle against the settling Israelites led by Joshua is reported in Joshua 10:1-15. Along with the other four kings, he was subsequently found in a cave at Makkedah, where he was killed and buried by Joshua and his forces (Joshua 10:26-27).
-On On, the son of Peleth, of the Tribe of Reuben, was a participant in Korah’s rebellion against Moses according to Numbers 16:1. On is referred to as 'Hon' in the Douai Bible translation. He is mentioned alongside Korah, Dathan and Abiram as the instigators of the rebellion, but not referred to later when Korah, Dathan and Abiram were challenged and punished for their rebellion.
-Elienai Elienai, one of the nine sons of Shimei, appears in a genealogical passage as a descendant of Benjamin in 1 Chronicles 8:20. The consonants which make up the Hebrew name are only in this one passage read as Elienai; elsewhere the pronunciation is Elioenai.[104]
-Elpalet See Eliphelet (biblical figure)
-Hammoleketh Hammoleketh or Hammolecheth is the sister of Machir, the eponymous ancestor of the tribe or clan of Machir (biblical region) Machir, which is reckoned as a part of the tribe of Manasseh in 1 Chronicles 7. The name appears to mean 'she who reigns' if it is not a scribal error for some other name, such as Beth-Milcah.[146]
-Iru Iru is a name mentioned only once in the Hebrew Bible.[213] In 1 Chronicles 4:15, Iru is listed as one of the sons of Caleb. The other two were Elah and Naam.
-Ithream Ithream was the son of David and Eglah, David's sixth son, according to II Samuel 3:5.
-Jerioth #2 Wife of Caleb (son of Hezron) I Chronicles[84]
-Iri Iri, according to 1 Chronicles 7:7, was one of the sons of Bela, who was the son of Benjamin, eponymous founder of the Tribe of Benjamin. In verse 12, he is referred to simply as Ir.[211]
-Jochebed Mother of Moses, Aaron, and Miriam. Exodus, Numbers[91][92]
-Jehdeiah Jehdeiah is the name of two individuals in the Hebrew Bible.[267] A Levite mentioned in 1 Chronicles 24:20. Jehdeiah the Meronothite, who according to 1 Chronicles 27:30 was in charge of king David's donkeys.
-Asiel Asiel is listed as one of the descendants of Simeon in 1 Chronicles 4:35.
-Shimshai Shimshai was a scribe who was represented the peoples listed in Ezra 4:9-10 in a letter to King Artaxerxes.
-Rezon According to I Kings 11:23- Rezon (Hebrew: רזון Rezon 'Thinness') became regent in Damascus and was an adversary of Solomon.
-Hanniel Hanniel Prince of the tribe of Manasseh; one of those appointed by Moses to superintend the division of Canaan amongst the tribe (Num. 34:23).
-Hashabiah Hashabiah is a biblical name that appears frequently for individuals mentioned after the Babylonian captivity.[159] Because the name often appears in lists without any detailed description, it is sometimes difficult to tell whether different verses that use the name are referring to the same Hashabiah or to distinct persons.[159] The following list of nine individuals is the number listed in the Encyclopaedia Biblica, though the encyclopedia does not claim that precisely nine people of this name are mentioned: A Levite of the Merarite group, mentioned 1 Chronicles 6:45 (verse 30 in some Bibles). Hashabiah son of Bunni, a Merarite Levite listed as living in Jerusalem in 1 Chronicles 9:14 and Nehemiah 11:15. A leader of a large group of people in the time of David.[160] A musician.[161] Hashabiah son of Kemuel, identified as the leader of the Levites in the time of David.[162] A Levite leader in the time of Josiah.[163] A Levite identified as having signed the covenant between Ezra and God.[164] A ruler listed as one of the people responsible for repairing the wall of Jerusalem in Nehemiah 3:17. The ruler of the clan of Hilkiah, according to Nehemiah 12:21.
-Maadiah Maadiah appears in a list of priests and Levites said to have accompanied Zerubbabel in Nehemiah 12:5.
-Akan In Genesis 36:27 Akan is a son of Ezer and grandson of Seir the Horite. In 1 Chronicles 1:42 he is called Jaakan.
-Rakem See Rekem.
-Hanoch Hanoch is the name of two biblical figures.[149] A son of Midian, the eponymous forefather of the Midianites.[13] A son of Reuben, the eponymous forefather of the Tribe of Reuben.[150] According to Cheyne and Black, the presence of this clan name in the genealogy of Reuben and Midian may indicate that the clan Hanoch was considered a part of the Tribe of Reuben but had a Midianite origin.[149]
-Huppim Huppim (חופי×) or Hupham (חופ×) was the ninth son of Benjamin in Genesis 46:21 and Numbers 26:39.
-Hananiah Hananiah (Hebrew: ×—× × ×™×”, which means 'My Grace is the Lord'[148]) is the name of at least two biblical characters: Hananiah son of Zerubbabel, the father of Jeshaiah, was a descendant of David. Hananiah son of `aZOoR, a prophet in the time of king Zedekiah. He opposed the prophet Jeremiah, was denounced by Jeremiah, and died within a year of denunciation. Jeremiah chapter 28.
-Baanah (Hebrew: ×‘Ö·×¢Ö²× Ö¸×) Baanah the Netophathite was the father of Heleb, one of King David's Warriors (2 Samuel 23:29, 1 Chronicles 11:30). Baanah the son of Ahilud, was one of Solomon's twelve regional administrators, having jurisdiction over Taanach, Meggido, and Beth-shean (I Kings 4:12). Baanah the son of Hushai, was one of Solomon's twelve regional administrators, having jurisdiction over Asher and [Bealoth|Aloth] (I Kings 4:16).
-Azgad Azgad is the name of a Levite who signed Ezra's covenant.[76] The name means 'Gad is strong.'[77]
-Jehubbah Jehubbah (or Hubbah) is the name of an individual who appears in a genealogy of the Tribe of Asher. His name depends on which variant reading (see Qere and Ketiv) of the Masoretic Text one follows: the Ketiv reads yhbh ('Jehubbah') the Qere reads whbh ('and Hubbah').[275]
-Eliada Eliada (rendered once as Eliadah by the King James Bible) is the name of three individuals in the Hebrew Bible. The son of David, who was originally called Beeliada.[99] A Benjamite captain in the time of king Jehoshaphat.[100] The father of Rezon the Syrian, spelled 'Eliadah' in the King James Version.
-Pedahzur Pedahzur was a member of the house of Manasseh according to Numbers 1:10. He was the father of Gamaliel.
-Johanan son of Kareah Johanan (Hebrew: ×™×•×—× ×Ÿ 'God is merciful') son of Kareah was among the officers who survived the destruction of Jerusalem and exile of Judeans by the king of Babylon; he warned Gedaliah, the governor, of a plot to kill him, but was ignored. Jeremiah 40 7ff.
-Chimham Chimham accompanied King David to Gilgal after the death of Absalom. (2 Samuel 19:37-40) Also a place near Bethlehem where Johanan regrouped before departing to Egypt. Jeremiah 41:17 [90]
-Atarah second wife of Jerahmeel. I Chronicles[23]
-Ben Abinadab Ben Abinadab (Hebrew ×‘× ××‘×™× ×“×‘ BeN ,'aḄYNaDaḄ 'My Father is Liberal'), was one of King Solomon's twelve regional administrators; he was over Dor, and he was married to Taphath, a daughter of Solomon. I Kings 4:11 (RSV).
-Helkai Helkai is a name used in Nehemiah 12:15, in a list of priestly clan leaders in the 'days of Joiakim.'[173] The text refers to Helkai as leading a clan named Meraioth. According to the Encyclopaedia Biblica, the name is an abbreviated form of 'Hilkiah.'[174]
-Hasrah Hasrah, according to 2 Chronicles 34:22, is the name of an ancestor of Shallum, the husband of the prophetess Huldah. However, where the Book of Chronicles has 'Hasrah,' 2 Kings 22:14 has 'Harhas.'[156]
-Phaltiel For the individual called 'Paltiel' in the King James Bible, see Palti, son of Laish.
-Pedahel Pedahel Prince of the tribe of Naphtali; one of those appointed by Moses to superintend the division of Canaan amongst the tribe (Num. 34:28).
-Persis a 'woman who has worked hard in the Lord' whom Paul the Apostle greeted. Romans.[149]
-Zaavan Zaavan (za'-a-van or za'-awan) ('terror, trembling'), son of Ezer, was a Horite chief in the Land of Edom. (Gen. 36:27, 1 Chr. 1:42)
-Merab 'Merab' redirects here. For the masculine given name, see Merab (given name). Merab, meaning 'Increase' or 'Majority', was the eldest of Saul's two daughters (1 Samuel 14:49). She was offered in marriage to David after his victory over Goliath, but does not seem to have entered heartily into this arrangement (1 Samuel 18:17-19). She was at length, however, married to Adriel of Abel-Meholah, a town in the Jordan valley, about 10 miles south of Bethshean (Beit She'an), with whom the house of Saul maintained an alliance. She had five sons, who were all put to death by the Gibeonites on the hill of Gibeah (2 Samuel 21:8). Merab is also a common feminine name in Israel.
-Melchi 'My king' the son of Addi, and father of Neri (Luke 3:28), (Luke 3:24).
-Amaziah In Amos 7:10, Amaziah is a priest of Bethel who confronts Amos and rejects his prophesying against king Jeroboam II. As a result, Amos is led to prophesy the doom of Amaziah's family, the loss of his land and his death in exile. Jonathan Magonet has described Amaziah as 'a spiritual leader who believed in his own power and could not risk hearing the word of God'.[49]
-Naum See Nahum.
-Anan Anan was one of the Israelites who sealed the covenant after the return from Babylon[54] (Nehemiah 10:26).
-Matred #2 Genesis, I Chronicles[125][126]
-Anak Anak was the father of Ahiman, Sheshai, and Talmai in Numbers 13:22
-Anah In the Book of Genesis, there are two men and one woman named Anah. In Genesis 36:2,14,18,25, Anah is a daughter of Zibeon, and her daughter Aholibamah is a wife of Esau. In Genesis 36:20,29 and 1 Chronicles 1:38, Anah is a son of Seir and a brother of Zibeon chief of the Horites. In Genesis 36:24 and 1 Chronicles 1:40-41, Anah is a son of Zibeon, and is famed for discovering hot springs.
-Michri 'Prize of Jehovah' or 'Selling', a Benjamite, the father of Uzzi (1 Chronicles 9:8).
-Nahum Nahum, in addition to being the name of the well-known biblical prophet Nahum, is also the name of a figure mentioned in passing in Luke's version of the genealogy of Jesus.[25] The Nahum of Luke has his name spelled Naum in the King James Version.
-Jerioth Jerioth was a wife of Caleb according to 1 Chronicles 2:18.
-Ir See Iri (biblical figure).
-Claudia #2 greeted by Paul the Apostle. 2 Timothy[39]
-Julia Julia was a Christian woman at Rome to whom Paul sent his salutations in Romans 16:15, supposed to be the wife of Philologus.[308]
-Jahzerah Jahzerah is a name which appears only in 1 Chronicles 9:12.[248] See Ahzai.
-Maacah #2 Sister of Makir, father of Gilead. Mentioned one verse later is Makir's wife, also named Maacah. Difficult to determine whether they are the same person or not. 'I Chronicles'[105]
-Asriel Asriel was a son of Manasseh according to Numbers 26:31, Joshua 17:2, and 1 Chronicles 7:14.
-Elizaphan Elizaphan was a prince of the tribe of Zebulun; one of those appointed by Moses to superintend the division of Canaan amongst the tribe (Num. 34:25).
-Elpelet See Elpelet
-Hammedatha Hammedatha was an Agagite and the father of Haman (see Esther 3:1).
-Nahbi Nahbi, the son of Vophsi of the house of Naphtali, was a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:14.
-Iscah #2 Daughter of Abraham's younger brother Haran Genesis[75]
-Joelah Joelah, in 1 Chronicles 12:7, is listed as one of the Benjamite warriors who went to David at Ziklag.
-Dodavahu Dodavahu or Dodavah, according to Chronicles, was the father of Eliezer, a prophet.[95]
-Jeezer Jeezer was a son of Gilead of the Tribe of Manasseh according to Numbers 26:30.
-Josibiah See Joshibiah.
-Shaharaim Shaharaim was a member of the house of Benjamin. He had three wives, Hushim, Baara, and Hodesh, according to 1 Chronicles 8:8-9.
-Elishama Elishama (Hebrew: ×לישמע my God heard) was the name of several biblical characters, including: Elishama, a son of Ammihud, a prince of the house of Ephraim and one of the leaders of the tribes of Israel, according to Numbers 1:10. Elishama the scribe (Jeremiah 36:12)
-Saph Saph is a figure briefly mentioned in a section of 2 Samuel which discusses four yelide haraphah killed by Israelites. According to 2 Samuel 21:18, a war broke out between Israel and the Philistines. During the battle, Sibbecai the Hushathite, one of David's Mighty Warriors, killed Saph, who was one of the four. The expression yelide haraphah is rendered several different ways in translations of the Bible: 'the descendants of Rapha' (NIV, NLT), 'the descendants of the giants' (ESV, NLT[33]), 'the descendants of the giant' (NASB, Holman), and 'the sons of the giant' (KJV, ASV). While most interpreters the phrase as a statement about the ancestry of the four people killed, describing them as descended from giants, another interpretation takes the phrase as meaning 'votaries of Rapha,' in reference to a deity by that name to which a group of warriors would have been associated.[34][35]
-Tryphosa Tryphosa was a Christian mentioned in Romans 16:12 with other saints to whom Paul the apostle sent greetings and salutations.
-Judith Hittite wife of Esau. Genesis[93]
-Azzan Azzan (Hebrew עַזָּן 'strong') was the father of Paltiel, a prince of the Tribe of Issachar. (Num. 34:26).
-Nobah Nobah, of the Tribe of Manasseh defeated the Amorites, took the villages of Kenath and renamed it Nobah according to Numbers 32:42.
-Hazelelponi (or Hazzelelponi) daughter of Etam, tribe of Judah I Chronicles[65]
-Barachel Barachel was a Buzite, and was the father of Elihu, an antagonist of Job, according to Job 32:2.
-Eunice Timothy[53]
-Bithiah daughter of Pharaoh, Wife of Mered, a descendant of Judah. I Chronicles[37]
-Nehushta Nehushta was the wife of King Jehoiakim and daughter of Elnathan ben Achbor of Jerusalem, according 2 Kings 24:8. She was also the mother of King Jehoiachin.
-Laish This entry is about the individual named Laish. For the city Dan, known also as Laish, see Dan (ancient city). Laish is a name which appears in 1 Samuel 25:44 and 2 Samuel 3:15, where it is the name of the father of Palti, or Paltiel, the man who was married to Saul's daughter Michal before she was returned to David.
-Jushab-hesed Jushab-hesed is a name which appears in the Hebrew Bible only in 1 Chronicles 3:20, where he is said to be one of the sons of Zerubbabel.[309]
-Sarah #2 wife of Tobias. Tobit[182]
-Jonathan son of Kareah Jonathan (Hebrew: ×™×•× ×ª×Ÿ 'God gave') son of Kareah was among the officers who survived the destruction of Jerusalem and exile of Judeans by the king of Babylon; he was brother to Johanan q.v. - Jeremiah 40:8
-Jecholiah Jecholiah (Hebrew: יכליהו, yekhalyahu) of Jerusalem was the wife of the King of Judah, Amaziah, and the mother of King Azariah.[262] Depending on translation used, her name may also be spelled Jechiliah, Jecoliah, or Jekoliah.
-Sarah #1 wife of Abraham and the mother of Isaac. Her name was originally 'Sarai'. According to Genesis 17:15 God changed her name to Sarah as part of a covenant with Yahweh after Hagar bore Abraham a son Ishmael. Genesis, Isaiah, Romans, Galatians, Hebrews, I Peter[176][177][178][179][180][181]
-Hushim Hushim or Shuham was a son of Dan according to Genesis 46:23 and Numbers 26:42. He was one of the 70 souls to migrate to Egypt with Jacob.
-Dorcas, also known as Tabitha. Acts[46]
-Zithri In Exodus 6:22, Zithri ('the Lord protects'), a Levite, was the son of Uzziel.
-Julia #2 Minor character in the new testament Romans [94]
-Shephatiah Shephatiah (Hebrew שפטיה 'God is my judge') is the name of at least two Hebrew Bible men: Shephatiah the son of David and Abital, David's fifth son, according to II Samuel 3:4. Shephatiah the son of Mattan (Jeremiah 38:1) who was among the officers who denounced Jeremiah to king Zedekiah.
-Aziel See Jaaziel.
-Naphish Naphish (once Nephish in the King James Version) is the name given by the Bible to one of the sons of Ishmael, and to an Ishmaelite tribe.[26]
-Anna the Prophetess aged Jewish prophetess who prophesied about Jesus at the Temple of Jerusalem. Luke[20]
-Keren–Happuch One of Job's daughters. Job[96]
-Marsena Marsena is listed by Esther 1:14 as one of seven Persian officials working for king Ahasuerus.
-Elasah Elasah or Eleasah (Hebrew: ×לעשה meaning 'made by God') was the name of four individuals mentioned in the Bible: The son of Shaphan, who was chosen by King Zedekiah of Judah to be one of the two messengers to take Jeremiah's letter to Nebuchadnezzar (Jeremiah 29:3) He was probably the brother of Ahikam, who had taken Jermiah's part at the time of his arrest after the temple sermon [96] One of the sons of Pashur who was rebuked for marrying a foreign women (Ezra 10:18-19) The son of Helez, a Jerahmeelite (1 Chronicles 2:39-40). He is called 'Eleasah' in the King James Bible.[97] A descendant of Saul according to 1 Chronicles 8:37. He is called 'Eleasah' in the King James Bible.[97]
-Jezrahiah See Izrahiah.
-Poratha Poratha, according to Esther 9:8, was one of the ten sons of Haman, the antagonist of the Book of Esther who attempted to wipe out the Jewish people.
-Tyrannus Tyrannus was the operator of a school in Ephesus which the apostle Paul used as a base according to Acts 19:9
-Shisha Shisha (Hebrew - שיש×) was the father of Elihoreph and Ahijah, who were secretaries to King Solomon. 1 Kings 4:3.
-Imrah Imrah is a biblical name which appears only in 1 Chronicles 7:36, in a genealogy of the Tribe of Asher.[206]
-Ishuai See Ishvah.
-Claudia Claudia was an associate of Paul the Apostle who greeted Saint Timothy in 2 Timothy 4:21.
-Paruah Paruah is the name of a figure indirectly mentioned once in the Bible, in 1 Kings 4:17. In a passage which gives names of governors working under Solomon, a 'Jehoshaphat son of Peruah' is credited with governing the territory of the Tribe of Issachar.
-Phurah Phurah was a servant of Gideon in Judges 7. Gideon takes Phurah with him to spy on the Midianites before battle.
-Candace Ethiopian queen; a eunuch under her authority and in charge of her treasury was witnessed to by Philip the Evangelist, led to God and baptized. Acts[38]
-Eluzai Eluzai, in 1 Chronicles 12:6,[113] is the name of a Benjamite warrior who joined the forces of David at Ziklag. The name may have meant 'God is my refuge.'[114]
-Mibhar 'Choice', a Hagarene, one of David's warriors (1 Chronicles 11:38); called also Bani the Gadite (2 Samuel 23:36).
-Sheerah founded three towns. Descendant of Ephraim. I Chronicles[183]
-Ard Ard (Hebrew ×רד) was the tenth son of Benjamin in Genesis 46:21. It is relatively unusual among Hebrew names for ending in a cluster of two consonants instead of as a segholate.
-Jekuthiel Jekuthiel, father of Zanoah, appears in 1 Chronicles 4:18, in a genealogical passage concerning the Tribe of Judah.[284]
-Pinon Pinon is listed as one of the 'chiefs' of Edom, in Genesis 36:41, and, in a copy of the same list, in 1 Chronicles 1:52.
-Huldah Prophet II Kings, II Chronicles[72][73]
-Keturah Wife of Abraham after Sarah's death. Genesis, I Chronicles[97][98]
-Phuvah Phuvah or Pua was a son of Issachar according to Genesis 46:13 and Numbers 26:23. He was one of the 70 souls to migrate to Egypt with Jacob.
-Chelub Two individuals by the name of Chelub are mentioned in the Hebrew Bible. A descendant of Judah, called 'brother of Shuhah' in 1 Chronicles 4:11, in a genealogical passage listing descendants of Judah. According to the Encyclopaedia Biblica (1899), this 'Chelub' is the biblical figure better known as Caleb.[85] An Ezri son of Chelub was an overseer of agricultural work in the time of king David according to 1 Chronicles 27:26.
-Ahitub Ahitub is the name of multiple minor biblical figures. Ahitub, son of Phinehas, grandson of Eli, and brother of Ichabod. (1Samuel 14:3,22:9-20, 1Chronicles 9:11) Ahitub, son of Amariah and father of Zadok. (2Samuel 8:15-17) Ahitub, a descendant through the priestly line of the first Zadok. He was an ancestor of later high priests who served during the fall of Jerusalem and post-exile. (1Chronicles 6:11-12) Ahitub, a Benjamite. (1Chronicles 8:11)
-Zippor Zippor was the father of Balak, the king of Moab, in Numbers 22
-Harbona Harbona or Harbonah is the name given for one the eunuchs of king Ahasuerus in Esther 1:10 and 7:9.[151]
-Jibsam See Ibsam.
-Jerah Jerah was a son of Joktan according to Genesis 10:26, 1 Chronicles 1:20.
-Jedidah Wife of wicked king Manessah and mother of Josiah. II Kings[79]
-Palti This is about the Palti mentioned in Numbers. For the other biblical Palti, see Palti, son of Laish. Palti, the son of Raphu of the house of Benjamin, was a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:9.
-Abijah Abijah (Hebrew ×ֲבִיָּה 'my father is YHWH') is the name of eight biblical individuals.
-Hothir Hothir is listed as a son of David's 'seer' Heman in 1 Chronicles 25:4 and 28.
-Ahian Ahian is the name given to a descendant of Manasseh in the tribal genealogies of 1 Chronicles.[39] The name appears only in a single time in the Bible.[40]
-Hemam Hemam or Homam is the name of the son of Lotan and grandson of Seir the Horite, according to Genesis 36:22 and 1 Chronicles 1:39.
-Eglah #2 One of King David's wives. II Samuel, I Chronicles[7][47]
-Ben-Ammi Ben-Ammi (Hebrew בן־עמי for 'son of my people' [79]) was the son of Lot and his youngest daughter. He became the father of the Ammonites (see Genesis 19:36-38).
-Hiram Hiram (Hebrew: ×—×™×¨× á¸¤iram) of Tyre, son of a widow of the tribe of Naphtali whose father was a craftsman in bronze, was given the metal work of King Soloman's temple. I Kings 7:13-14. According to The Interpreter's Bible, Hiram is a shortened form of ××—×™×¨× ('aḥîrÄm, 'brother of Ram [the lofty one].')[183]
-Eliadah See Eliada.
-Adah # 1 wife of Lamech, Genesis[11]
-Geuel Geuel, the son of Machi of the Tribe of Gad, was a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:16.
-Gamaliel Gamaliel, son of Pedahzur was leader of the tribe of Manasseh, one of the leaders of the tribes of Israel, mentioned several times in the Book of Numbers.
-Nehum See Rehum.
-Merib-baal Meaning 'Contender with Baal,' (1 Chronicles 8:34),(1 Chronicles 9:40), elsewhere called Mephibosheth (2 Samuel 4:4), the son of Jonathan.
-Zohar For the Zohar found in a variant reading of 1 Chronicles 4:7, see Izhar. Zohar or Zerah was a son of Simeon according to Genesis 46:10, Exodus 6:15, and Numbers 26:13.[57] He was one of the 70 souls to migrate to Egypt with Jacob.
-Jahzeiah Jahzeiah (KJV Jahaziah) son of Tikvah is one of the figures listed in the Book of Ezra as opposing Ezra's prohibition on marriages with foreign women.[246][247]
-Sabtechah Sabtechah was a son of Cush according to Genesis 10:7, 1 Chronicles 1:9.
-Shiphtan Shiphtan was the father of Kemuel, a prince of the Tribe of Ephraim. (Num. 34:24).
-Jakeh Jakeh is a name that appears only in Proverbs 30:1, where part of the Book of Proverbs is ascribed to a man called 'Agur son of Jakeh'. Franz Delitzsch proposed that the name 'Jakeh' means 'scrupulously pious.'[249]
-Naaman Naman is the fifth son of Benjamin in Genesis 46:21 but his grandson according to Numeri 26:38 and 1 Chronicles 8:4
-Azariah Azariah (Hebrew - עזריהו azaryahu 'God Helped'), son of Nathan, was appointed by King Solomon to be over his deputies. I Kings 4:5. For Azariah the priest see Azariah (high priest).
-Ahlai Ahlai is a name given to two individuals in the Books of Chronicles. In the opinion of Thomas Kelly Cheyne, the name is probably derived from 'Ahiel' or a similar name.[43] The first is either the son or daughter of a Jerahmeelite man named Sheshan.[43] The second is the father or mother of Zabad, who is listed as one of David's Mighty Warriors in 1 Chronicles 11:41.[43]
-Athaiah Athaiah the son of Uzziah is a person listed in Nehemiah as a Judahite inhabitant of Jerusalem.[69] The meaning of the name is uncertain.[70]
-Adah #2 daughter of Elon, the Hittite and one of the wives of Esau. Possibly original name of Bashemath. Genesis[12]
-Ezbon Ezbon is the name of two people mentioned in the Bible: A son of Gad (Genesis 46:16). In Numbers 26:16 his name is given as Ozni, whose descendants constitute the Oznite clan. A son of Benjamin (1 Chr. 7:7).
-Nogah Nogah, a son of David, appears in two lists of David's sons: 1 Chronicles 3:7 and 1 Chronicles 14:6.
-Sachia Sachia (also Sakia) appears only in 1 Chronicles 8:10, where he is listed as one of the 'sons' of Shaharaim. The King James Version spells the name Shachia.
-Eliasaph Eliasaph was the name of two individuals mentioned in the Bible: The son of Deuel, the prince of the Tribe of Gad and one of the leaders of the tribes of Israel, according to Numbers 1:14 and Numbers 10:20. The son of Lael and the chief of the house of Gershon according to Numbers 3:24.
-Parshandatha Parshandatha was one of the ten sons of Haman. He was killed by a Jew or Jews (the Bible is unclear) and Esther had his corpse impaled (see Esther 9:5-14).
-Paltiel This is about the Paltiel in the Book of Numbers. For the other Paltiel, see Palti, son of Laish. Paltiel (Hebrew פַּלְטִי×ֵל 'delivered by God') was a prince of the tribe of Issachar, one of those appointed by Moses to superintend the division of Canaan among his tribe (Num. 34:26).
-Jeatherai See Ethni.
-Gomer Wife of Hosea and a prostitute. Hosea[56]
-Reba Reba was one of five Midianite kings killed during the time of Moses by an Israelite expedition led by Phinehas, son of Eleazar according to Numbers 31:8 and Joshua 13:21.
-Eldaah Eldaah appears as one of the sons of Midian (son of Abraham) in Genesis 25:4 and 1 Chronicles 1:33.
-Jaasiel Jaasiel (Jasiel) is the name of one of David's Mighty Warriors.[237] He is referred to in Hebrew as hammitsovayah, which has been variously translated as 'the Mezobaite,' 'the Mesobaite,' or 'from Zobah.'[238][239] A 'Jaasiel son of Abner' is listed as a Benjamite leader in 1 Chronicles 27:21, who may be the same person.[238]
-Agee Agee was the father of Shammah, who was one of David's mighty men (II Samuel 23:11). Based on interpretations of I Chronicles 11:34 and II Samuel 23:32-33 Agee was either the grandfather of Jonathan or his brother. According to Cheyne and Black, his name is a scribal mistake, and should read 'Ela'; he is the same as the Ela mentioned in 1 Kings 4:18.[37]
-Letushim Letushim appears as a son of Dedan according to Genesis 25:3.
-Anaiah Anaiah, a name meaning 'Yahweh has answered,' appears only twice in the Hebrew Bible, with both appearances in Nehemiah.[51] The first appearance describes Ezra, a Jewish reformer, standing up to give a speech, with thirteen other people standing beside him. Anaiah is listed as one of those standing by.[52] The second appearance of the name is in a list of people who signed a covenant between God and the Jewish people.[53]
-Jezoar See Izhar.
-Mnason 'Reminding, or remembrancer'. A Christian of Jerusalem with whom Paul lodged (Acts 21:16). He was apparently a native of Cyprus, like Barnabas (Acts 11:19-20), and was well known to the Christians of Caesarea (Acts 4:36). He was an 'old disciple' (R.V., 'early disciple'), i.e., he had become a Christian in the beginning of the formation of the Church in Jerusalem.
-Lael Lael (Hebrew לָ×ֵל 'belonging to God') was a member of the house of Gershon according to Numbers 3:24. He was the father of Eliasaph.
-Ismaiah See Ishmaiah.
-Barkos Barkos was a painter who was the father of some of the Nethinim, according to Ezra 2:53.
-Regem-melech A figure called Regem-melech, along with a 'Sharezer', came, according to some interpretations of Zechariah 7:2, to Bethel to ask a question about fasts. It is unclear whether the name is intended as a title or as a proper name.[30] The grammar of the verse is difficult and several interpretations have been proposed.[31]
-Abimael In Genesis 10:28, Abimael is the ninth of the 13 sons of Joktan, a descendant of Shem. He is also mentioned in 1 Chronicles 1:22. Abimael means 'God is a father.'[23]
-Zidkijah Zidkijah is mentioned in chapter 10 of Nehemiah.
-Ephod Ephod was the father of Hanniel, a prince of the Tribe of Manasseh. (Num. 34:23).
-Karshena See Carshena.
-Jeziah See Izziah.
-Mushi Mushi (Hebrew מוּשִ××™ 'touch, sensitive') was a son of Merari of the house of Levi according to Exodus 6:19, born in Egypt.
-Ramiah Ramiah, according to Ezra 10:25, was an Israelite layperson, a member of the group named 'sons of Parosh', who was guilty of marrying a foreign woman.
-Zurishaddai In Numbers 1:2, Rock of the Almighty ('Shaddai is my rock') was the father of Shelumiel, the prince of the Tribe of Simeon. He is mentioned in this context five times in the Book of Numbers.[58]
-Ruth Boaz and Ruth get married and have a son named Obed. Obed is the descendant of Perez the son of Judah, and the grandfather of (king) David. Ruth, Matthew[170][171]
-Zerah See Zohar.
-Jamin The name Jamin means right hand. There are three different Jamins in the Bible: a son of Simeon according to Genesis 46:10, Exodus 6:15, and Numbers 26:12. He was one of the 70 souls to migrate to Egypt with Jacob. Man of Judah, see 1 Chronicles 2:27 Post exile Levite who interpreted the law, see Nehemiah 8:7,8
-Obil Obil was an Ishmaelite, a keeper of camels in the time of David, according to 1 Chronicles 27:30.
-Ben Geber Ben Geber (Hebrew ×‘× ×’×‘×¨ BeN GeḄeR 'Son of He-Man'), was one of King Solomon's twelve regional administrators; he was over Ramoth Gilead and Argob. I Kings 4:13 (RSV).
-Chenaniah Chenaniah, according to Chronicles, was a Levite leader in the time of David.[88] The Hebrew text is unclear as to whether he was in charge of something to do with singing or with the carrying of the ark.[89]
-Hodesh Hodesh is a figure who appears in a genealogy of the Tribe of Benjamin in Chronicles.[187] The name might mean 'born at the feast of the new moon,' or else it may be a misspelling of Ahishahar.[188]
-Sethur Sethur, the son of Michael of the house of Asher, was a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:13.
-Ishbi-benob Ishbi-benob is a name which appears in the Qere of the Masoretic Text at 2 Samuel 21:16.[214] Qere is the term for the version of the text traditionally read aloud in synagogues. The Ketiv, the version written but not read aloud, reads somewhat differently, in a manner that suggested to Thomas Kelly Cheyne that the opening words of the verse were not the name of the giant, but words that indicated that David and his soldiers stayed in (the city) Nob.[214] Whatever the case with the Ketiv, the Qere as it now stands asserts that Ishbi-benob was the name of a Philistine giant, who was killed by Abishai son of Zeruiah.[214][215]
-Jesher Jesher the son of Caleb is mentioned only in 1 Chronicles 2:18.
-Rehabiah Rehabiah is a figure mentioned three times in the Hebrew Bible, as the ancestor of a group of Levites. He is identified as the son of Eliezer the son of Moses (1 Chronicles 23:17; 26:25). Chronicles identifies his as the father of a person named Isshiah (Hebrew YiÅ¡Å¡iyÄh, 1 Chronicles 24:21) or Jeshaiah (Hebrew YÄ•shaÊ¿yÄhû, 1 Chronicles 26:25).
-Maaseiah Maaseiah (Hebrew מעשיהו maaseyahu 'Work of God') is the name of several men in the Hebrew Bible: One of the Levites whom David appointed as porter for the ark 1 Chronicles 15:18, 1 Chronicles 15:20 One of the 'captains of hundreds' associated with Jehoiada in restoring king Jehoash to the throne 2 Chronicles 23:1 The 'king's son,' probably one of the sons of king Ahaz, killed by Zichri in the invasion of Judah by Pekah, king of Israel 2 Chronicles 28:7 One who was sent by king Josiah to repair the temple 2 Chr. 34:8. He was governor (Heb. sar, rendered elsewhere in the Authorized Version 'prince,' 'chief captain,' chief ruler') of Jerusalem. The father of the priest Zephaniah Jer. 21:1,Jer. 37:3 The father of the false prophet Zedekiah Jer. 29:21 a priest, the father of Neriah Jer. 32:12, Jer. 51:59 The son of Shallum, 'the keeper of the threshold' (Jeremiah 35:4) 'may be the father of the priest Zephaniah mentioned in [Jeremiah] 21:1; 29:25; 37:3.' [7]
-Akkub In Ezra 2:45, Akkub is the head of a family of Nethinim. In 1 Chronicles 3:24, Akkub is a son of Elionenai, descendant of Solomon living in the Kingdom of Judah. In 1 Chronicles 9:17, Ezra 2:42, and Nehemiah 7:45, Akkub is a Levite gatekeeper at the Temple in Jerusalem after the return from the Babylonian captivity.
-Eshek Eshek is a name which appears only once in the Hebrew Bible, in a genealogy of the Tribe of Benjamin.[118][119] The text of Chronicles identifies him as the brother of Azel.
-Hamor Hamor was the father of Shechem. Shechem defiled Dinah according to Genesis 34
-Peninnah Wife of Elkanah. I Samuel[148]
-Jekoliah See Jecholiah.
-Abdon Abdon (Hebrew עַבְדּוֹן from עָבַד 'to serve') is the name of four biblical individuals. It is a diminutive form of the name Ebed.[10] An Abdon in the book of Judges: see the article Abdon (Judges). The first-born of Gibeon of the tribe of Benjamin, mentioned only in passing in genealogies (1 Chronicles 8:30, 9:36). Abdon the son of Micah. Josiah sent him, among others, to the prophetess Huldah, in order to discern the meaning of the recently rediscovered book of the law (2 Chronicles 34:20). He is referred to as Achbor in 2 Kings 22:12. Abdon son of Sashak. He is only mentioned as a name in a genealogy (1 Chronicles 8:23).[11] In addition to its use as a personal name, the proper name 'Abdon' is used for a Levitical city mentioned in Joshua 21:30 and 1 Chronicles 6:74 (6:59 in some versions).[12]
-Shemuel Shemuel Prince of the tribe of Simeon; one of those appointed by Moses to superintend the division of Canaan amongst the tribe (Num. 34:20).
-Adina In 1 Chronicles 11:42, Adina (lit. Slender) is listed as one of the 'mighty men' of David's army. Adina was the son of a chief of the Reubenites named Shiza.
-Nebuzaradan Nebuzaradan (the biblical form of his name, derived from the Babylonian form Nabu-zar-iddin, meaning 'Nabu has given a seed')[29] was the captain of Nebuchadnezzar's bodyguard, according to the Bible. He is mentioned in 2 Kings 25:8, 11, 20; Jeremiah 52:30; Jeremiah 39:11, 40:2, 5.
-Shelemiah Shelemiah (Hebrew: שלמיהו) the son of Abdeel, along with two others, was commanded by king Jehoiakim to arrest Baruch the scribe and Jeremiah the prophet Jeremiah (36:25).
-Jehiel This entry contains close paraphrases and borrowing of wording found in entries entitled 'Jehiel' the Encyclopaedia Biblica, a work that is now in the public domain. Jehiel is the name of fourteen figures in the Hebrew Bible.[269] For eleven of these the English spelling 'Jehiel' reflects the Hebrew name ×™×—×™×ל:[269] A Levite musician in the time of David (1 Chronicles 15:18, 20; 16:5). The leader of a family of Gershonite Levities in the time of David (1 Chronicles 23:8; 29:8). Jehiel the son of Hachmoni, who was with David's sons (1 Chronicles 27:32). Jehiel the son of king Jehoshaphat (2 Chronicles 21:2). A Hemanite Levite in the time of Hezekiah, called Jehuel in the Revised Version (2 Chronicles 29:14). A Levitical or priestly oversees of the temple in the time of Hezekiah (2 Chronicles 31:13). A person referred to as 'ruler of the house of God' in the time of Josiah (2 Chronicles 35:8). The father of Obadiah in a post-exilic list of kin groups (Ezra 8:9). The father of Shechaniah (Ezra 10:2). Jehiel the son of Harim, a priest (Ezra 10:21). Jehiel the son of Elam, a layman (Ezra 10:26). For the other three, the name Jehiel (or Jeiel) reflects the Hebrew spelling ×™×¢×™×ל. One of the sons of Elam (Ezra 10:2). A Gibeonite described as the 'father of Gibeon' in 1 Chronicles 9:35. A son of Hothan the Aroerite, who along with his brother Shama was listed as one of David's Mighty Warriors in 1 Chronicles 11:44.
-Abiel Abiel (Hebrew ×ֲבִי×ֵל 'my father is God') was the name of two individuals mentioned in the Bible: Son of Zeror, of the tribe of Benjamin, he was the grandfather of King Saul and of his commander Abner. 1 Samuel 9 An Arbathite, one of King David's Warriors who was known for his bravery. 1 Chronicles 11:32
-Zobebah Zobebah (also known as Hazzobebah)[56] was a son of Koz (1 Chronicles 4:8).
-Isshijah See Jesiah.
-Pildash Pildash was the son of Nahor and Milcah (Genesis 22:22).
-Uel In Ezra 10:34 : 'Of the sons of Bani; Maadai, Amram, and Uel.'
-Jehoiada Jehoiada (Hebrew: יהוידע,Yehoyada 'The LORD Knows'[272]) was the name of at least three people in the Hebrew Bible: Jehoiada, a priest during the reigns of Ahaziah, Athaliah, and Joash (q.v.) Jehoiada, father of Benaiah (cf. Benaiah) Jehoiada, a priest in the time of Jeremiah (Jeremiah 29:26)
-Pagiel Pagiel (Hebrew פַּגְעִי×ֵל 'approach God') was a son of Ocran, a prince of the house of Asher and one of the leaders of the tribes of Israel, according to Numbers 1:13.
-Maher-shalal-hash-baz Maher-shahal-has-baz ('Hurry to spoil!' or 'He has made haste to the plunder!') was the second mentioned son of the prophet Isaiah (Isaiah 8.1-4). The name is a reference to the impending plunder of Samaria and Damascus by the king of Assyria.
-Zalmon Zalmon the Ahohite, according to 2 Samuel 23:28 in the Masoretic Text, is listed as one of David's Mighty Warriors. In the Masoretic Text of 1 Chronicles 11:29, in another copy of the same list of warriors, he is called 'Ilai the Ahohite.'[50] Where the Masoretic Text has 'Zalmon,' various manuscripts of the Greek Septuagint have Ellon, Sellom, or Eliman.[50] And where the Masoretic Text has 'Ilai,' the Septuagint reads Elei, Eli, or Ela.[50]
-Ishijah See Jesiah.
-Bela Hebrew: בלע BeLa` 'Crooked' Bela was the name of three individuals mentioned in the Bible: Bela ben Beor, an Edomite king according to Genesis 36:32 and 1 Chronicles 1:43 (also 'Belah') The first of ten sons of Benjamin according to Genesis 46:21, Numbers 26:38, and 1 Chronicles 7 and 8. A son of Azaz according to 1 Chronicles 5:8
-Joahaz For either of the biblical kings names Jehoahaz or Joahaz, see Jehoahaz of Israel or Jehoahaz of Judah. Joahaz, according 2 Chronicles 34:8, was the name of the father of Josiah's scribe Joah.
-Ahuzzath Ahuzzath or Ahuzzah[46] is the name given to an associate of Abimelech, king of Gerar, in Genesis 26:26. According to the Book of Genesis, Ahuzzath accompanied Abimelech when Abimelech went to make a treaty with Isaac. He is mentioned nowhere else in the Hebrew Bible.[47]
-Susi Susi of the house of Manasseh was the father of Gaddi, a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:11.
-Joseph Joseph of the house of Issachar was the father of Igal, a scout sent to Canaan prior to the crossing of the Jordan River according to Numbers 13:7.
-Joanna One of the women who went to prepare Jesus' body for burial. Luke[90]
-Ephah one of the concubines of Caleb (prince of Judah) I Chronicles[50]
-Joshua the governor of the city Joshua (Hebrew: יהושע yehoshua 'God saves') was a city governor in the time of King Josiah of Judah. II Kings 23:8
-Peulthai Peulthai, according to 1 Chronicles 26:5, was the eighth of Obed-edom's eight sons. The passage in which they are listed records gatekeepers of the temple at Jerusalem.
-Hod Hod is a biblical name which appears only in 1 Chronicles 7:37.[184] He appears as one in character in a genealogy of the Tribe of Asher.
-Ispah See Ishpah.
-Hon See On (biblical figure)
-Mezahab 'Water of gold', the father of Matred (Gen 36:39),(1 Chronicles 1:50), and grandfather of Mehetabel, wife of Hadar, the last king of Edom.
-Chelluh Chelluh, Cheluhi, or Cheluhu is the name given in Ezra 10:35 for one of the men who married foreign women.[84]
-Shabbethai Shabbethai, a Levite who helped Ezra in the matter of the foreign marriages (Ezra 10:15), probably the one present at Ezra's reading of the law (Nehemiah 8:7), and possibly the Levite chief and overseer (Nehemiah 11:16). The name might mean 'one born on Sabbath', but more probably is a modification of the ethnic Zephathi (Zephathite), from Zarephathi (Zarephathite). Meshullam and Jozabad, with which Shabbethai's name is combined, both originate in ethnic names. (Encyclopaedia Biblica)
-Hamutal Wife of Josiah and mother of 'ungodly' sons Jehoahaz and Mattaniah. II Kings, Jeremiah[62][63]
-Asareel Asareel, according to a genealogical passages in the Book of Chronicles, was the son of a figure named Jehaleleel or Jehallelel.[65] Asareel and Jehaleleel are mentioned only briefly, in a section of the genealogies adjacent to the descendants of Caleb, although the relationship between them and the descendants of Caleb is uncertain.[66][67]
-Barzillai Barzillai [ברזלי 'Iron-like'] the Gileadite of Rogelim was 80 years old at the time of Absalom's revolt against King David. Barzillai supplied provisions for David's army at Mahanaim (2 Samuel 17:27-29). After the death of Absalom, Barzillai, being an old man, was unable to accompany the king back to Jerusalem, but brought Chimham to David for the return journey (2 Samuel 19:31-37). Another figure who married one of Barzillai's daughters was called Barzellai as a result (Ezra 2:61; Nehemiah 7:63). In 1 Esdras 5:38, he is called Zorzelleus.
-Judas of Straight Street in Damascus When he went blind at his conversion experience, Paul the Apostle stayed at the home of a man named Judas who lived on Straight Street in Damascus. Then, Jesus told Ananias to go to Judas' house and restore Paul's sight (see Acts 9:1-19).
-Jahaziah See Jahzeiah.
-Abiasaph Abiasaph (Hebrew ×ֲבִי×ָסָף 'my father has gathered') was a son of Korah of the house of Levi according to Exodus 6:24, born in Egypt. Ebiasaph is a spelling variation of Abiasaph.
-Massa Hebrew for a type of gift, one of the sons of Ishmael, the founder of an Arabian tribe (Gen. 25:14); a nomadic tribe inhabiting the Arabian desert toward Babylonia.
-Elnathan Elnathan (Hebrew ××œ× ×ª×Ÿ El-Natan 'God gave') is a Hebrew name found in both Jeremiah and Ezra. Elnathan ben Achbor of Jerusalem was the father of Nehushta. Nehushta conceived Jeconiah with King of Judah Jehoiakim. Despite this close relationship to the king, Elnathan is one of those who, according to Jeremiah 36:25 opposes Jehoiakim when he cuts up and burns a scroll that had been brought to him, containing Jeremiah's prophesies of the forthcoming destruction of Judah. Elnathan's father Achbor was a strong supporter of the earlier reforms of king Josiah, which may have influenced[110] Elnathan's behaviour - though he had earlier been closely involved in the persecution of the prophet Uriah ben Shemaiah, according to Jeremiah 26:20-23. In Ezra 8:16, the name Elnathan occurs three times. 'Then sent I for Eliezer, for Ariel, for Shemaiah, and for Elnathan, and for Jarib, and for Elnathan, and for Nathan, and for Zechariah, and for Meshullam, chief men; also for Joiarib, and for Elnathan, which were teachers' (Revised Version). According to Donna Laird, the repetition of Elnathan, and the similarity between the names Jarib and Joiarib, may indicate a copyist's accidental repetition.[111]
-Sheshan Sheshan is the name of one, or possibly two, biblical characters mentioned in the first book of Chronicles: 'The son of Ishi was Sheshan, and Sheshan’s son was Ahlai ... Now Sheshan had no sons, only daughters. And Sheshan had an Egyptian servant whose name was Jarha. Sheshan gave his daughter to Jarha his servant as wife, and she bore him Attai.'[44]
-Hodaviah Hodaviah is the name of three individuals in the Bible.[185] The Revised Version and King James Version of the Bible sometimes spell it as Hodaiah, Hodevah, or Hodeiah.[185] Hodaviah, a clan leader in the Tribe of Manasseh, according to 1 Chronicles 5:24. Hodaviah son of Hassenuah appears as the ancestor of a Benjamite man living in Jerusalem after the Babylonian captivity.[186] This Hodaviah is called 'Judah son of Hassenuah' in Nehemian 11:9.[185] Hodaviah son of Elioenai is described as a descendant of Zerubbabel in 1 Chronicles 3:24
-Janai Janai (Jaanai) is a name that appears only 1 Chronicles 5:12, where Janai is listed as a descendant of Gad. According to the Encyclopaedia Biblica, the name represents the name of a clan within the Tribe of Gad.[250]
-Hillel The father of Abdon, in the Book of Judges.
-Jakim This section is about individuals named Jakim. For the priestly division named Jakim, see the priestly division of Jakim. Jakim is the name of one individual mentioned in the Hebrew Bible, as well as one individual mentioned in some manuscripts of the New Testament's Gospel of Matthew. In a genealogy of the Tribe of Benjamin, in 1 Chronicles 24:12, a Jakim appears, as the son of Shimei (who is referred to as Shema in verse 13).[253] In some Greek manuscripts of Matthew, a Jakim appears between Josiah and Jechoniah in a genealogy of Jesus.[254][253]
-Jeriah See Jerijah.
-Bilhah Rachel's handmaid and a concubine of Jacob who bears him two sons, Dan and Naphtali. Genesis[36]
-Eliphelet Eliphelet is a Hebrew name meaning 'God is a deliverance.' [101] It is the name of several figures in the Hebrew Bible, and appears under several spellings.[101][103] Eliphelet is the name given to a son of David in 2 Samuel 5:16, and 1 Chronicles 3:8 and 14:7. Due to a textual error, Chronicles records Eliphelet twice, as if it were the name of two different sons of David.[101] Eliphal, son of Ur (2 Samuel 23:34) or Ahasbai (1 Chronicles 11:35), is listed as one of David's Mighty Warriors. The Encyclopaedia Biblica claims that 'Eliphal' is likely a scribal error for 'Eliphelet.'[101] Eliphal son of Eshek appears in a genealogy of the Tribe of Benjamin (1 Chronicles 8:39). An Eliphelet is named among the 'descendants of Adonikam,' one of the groups that returned with Ezra from the Babylonian captivity according to Ezra 8:13. An Eliphelet, one of the 'descendants of Hashum,' is listed as one of the men who married foreign women according to Ezra 10:33.
-Gishpa Gishpa, (KJV Gispa) was one of two leaders of the Nethinim who lived in Ophel, according to Nehemiah 11:21. There are no other mentions of the name anywhere else in the Bible.[130]
-Jemuel Jemuel was a son of Simeon according to Genesis 46:10, Exodus 6:15, and Numbers 26:12. He was one of the 70 souls to migrate to Egypt with Jacob.
-Sarsekim Sarsekim or Sarsechim is a name or title, or a portion of a name or title, which appears in Jeremiah 39:3. Jeremiah describes describes Babylonian officials, some named and the rest unnamed, who according to the text sat down 'in the middle gate' of Jerusalem during its destruction in 587 or 586 BCE. The portion which explicitly gives the names and/or titles of the officials reads, in Hebrew, nrgl śr ʾṣr smgr nbw śr skym rb srys nrgl śr ʾṣr rb-mg. Various interpretations have divided the names in various ways. The King James Version, sticking closely to the grammatical indicators added to the text by the Masoretes during the middle ages, reads this as indicating six figures: 'Nergalsharezer, Samgarnebo, Sarsechim, Rabsaris, Nergalsharezer, Rabmag'. The New International Version sees three characters 'Nergal-Sharezer of Samgar, Nebo-Sarsekim a chief officer, Nergal-Sharezer a high official.' Versions featuring these three figures, with variations in the exact details of translations, include NLT and ESV. Four figures appear in the New American Standard Bible, 'Nergal-sar-ezer, Samgar-nebu, Sar-sekim the Rab-saris, Nergal-sar-ezer the Rab-mag.' In 2007, a Babylonian Tablet was deciphered containing a reference to a 'Nabu-sharussu-ukin,' identified as referring to the biblical figure.[36] See Nebo-Sarsekim Tablet.
-Hepher Hepher was a son of Manasseh according to Numbers 26:32 and Joshua 17:2. See List of minor biblical places § Hepher.
-Hathath Hathath is only mentioned in 1 Chronicles 4:13, in a genealogical passage where he is the son of Othniel, the son of Kenaz.[169]
-Ebed The father of Gaal, mentioned in Judges 9. The son of Jonathan, one of the heads of household who returned from the Babylonian exile in the Book of Ezra (Ezra 1:6).
-Shagee Shagee (also spelled Shage or Shageh) is a figure who appears, indirectly, in one version of the list of David's Mighty Warriors. In 1 Chronicles 11:34, a figure appears who is called 'Jonathan the son of Shagee the Hararite.' In 2 Samuel 23:32-33, the name 'Jonathan' appears directly before the name 'Shammah the Harodite,' while in 2 Samuel 23:11 is found 'Shammah the son of Agee the Hararite,' who is the subject of a very brief story in which he fights with Philistines. The exact sort of copying error or deliberate abbreviation that may have lead to this state of affairs is uncertain.[40]
-Jonathan son of Abiathar Jonathan was a son of Abiathar the priest (2 Samuel 15:27), and served as a messenger during Absalom's rebellion. (2 Samuel 15:36, 17:17).
-Michaiah Michaiah (Hebrew: מיכיהו Mikay'hu 'Who is like Yah?') is the name of at least two biblical figures: Michaiah (or Micaiah), son of Imri (q.v.) Michaiah, the son of Gemariah, the son of Shaphan (Jeremiah 36:11), who heard Baruch's reading of the oracles of YHVH to Jeremiah, and reported to king Johoiakim
-Sapphira Acts[175]
-Chislon Chislon was the father of Elidad, a prince of the Tribe of Benjamin. (Num. 34:21)
-Jachin Jachin was a son of Simeon according to Genesis 46:10, Exodus 6:15, and Numbers 26:12, one of the 70 souls to migrate to Egypt with Jacob.
-Ziphah In 1 Chronicles 4:16, Ziphah (zī´fe) is mentioned as a son of Jehaleleel, a descendant of Judah.
-Mikloth 'Staves' or 'Looking Down'. An officer under Dodai, in the time of David and Solomon (1 Chronicles 27:4). A Benjamite (1 Chronicles 8:32),(1 Chronicles 9:37), (1 Chronicles 9:38).
-Hanameel Hanameel (Hebrew: ×—× ×ž×ל, which means 'Grace From God'[148]) A cousin of Jeremiah from whom the latter bought property. Jeremiah 32:7ff.
-Ishmaiah Ishmaiah (KJV Ismaiah) is the name of two biblical figures.[217] Ishmaiah son of Obadiah was the leader of the Tribe of Zebulun in the time of David, according to 1 Chronicles 27:19. He is called Samaias in the Septuagint.[217] Ishmaiah the Gibeonite, according to 1 Chronicles 12:4, was one of David's Mighty Warriors.
-Hobab Hobab was Moses' brother-in-law (Numbers 10:29) or father-in-law (Judges 4:11). The relevant part of Numbers 10:29 reads: 'And Moses said unto Hobab, the son of Reuel the Midianite, Moses' father-in-law'. That of Judges 4:11 reads: 'Now Heber the Kenite had severed himself from the Kenites, even from the children of Hobab the father-in-law of Moses'. Moses invited Hobab to take part in the Exodus journey into the Promised Land, wanting to make use of his local knowledge, but Hobab preferred to return home to Midian (Numbers 10:29-31).
-Jahath Jahath is the name of several individuals in the Hebrew Bible.[245] Jahath son of Reaiah, son of Shobal, son of Judah (son of Jacob) is mentioned in 1 Chronicles 4:2, in a genealogical passage describing the Tribe of Judah. Jahath is a name applied to various Levites in 1 Chronicles 6:20 (verse 5 in some Bibles), 6:43 (verse 28 in some Bibles), 23:10, 24:22; and 2 Chronicles 34:12.[245]
-Methushael In Genesis 4:18 Methushael is a descendant of Cain, the son of Mehujael and the father of Lamech.
-Leummim Leummim (Hebrew לְ×Ö»×žÖ´Ö¼×™× 'nations') was the third son of Dedan, son of Jokshan, son of Abraham by Keturah. (Genesis 25:3)
-Gamul Gamul (Hebrew: גָמוּל‎‎; 'rewarded' or 'recompense') was head of the twentieth of twenty-four priestly divisions instituted by King David.[121]
-Mahol Heb. 'Dance', the father of four sons 1 Kings 4:31 who were inferior in wisdom only to Solomon.
-Jarib Jarib is the name of three individuals in the Hebrew Bible, and appears once in the King James Version of 1 Maccabees 14:29. In 1 Chronicles 4:24, one of the sons of Simeon (son of Jacob) is called Jarib. In other passages, he is called Jachin.[251] A Jarib appears in a list of leaders recruited by Ezra to find Levites for the resettlement of Jerusalem.[252] A priest by the name of Jarib is mentioned in a list of men who married foreign women in Ezra 10:18. In 1 Maccabees 14:29, in the King James Version a priest named Simon is described as being 'of the posterity of Jarib.' The New English Translation of the Septuagint transliterates the name as Ioarib, while the New American Bible reads Joarib.
-Jaaziah Jaaziah is listed as one of the sons of Merari in a passage discussing the various divisions of Levites.[241]
-Zeruiah daughter or stepdaughter of Jesse of the Tribe of Judah, was an older sister of King David. Zeruiah had three sons, Abishai, Joab, and Asahel, all of whom were soldiers in David's army. II Samuel, I Chronicles[194][195]
-Hodesh #2 one of the wives of Shaharaim I Chronicles[68]
-Naamah #1 Sister of Tubal-cain. Genesis[141]
diff --git a/hw/hw2/starter-code/DATA/person_living.facts b/hw/hw2/starter-code/DATA/person_living.facts
deleted file mode 100644
index e238597dbf86ea0eca30d17adb76965d79e4dfe0..0000000000000000000000000000000000000000
--- a/hw/hw2/starter-code/DATA/person_living.facts
+++ /dev/null
@@ -1,22 +0,0 @@
-Abishag
-Mahalath
-Jaziz
-Ahab
-Salome #2
-Irad
-Pelaiah
-Damaris. Acts[41]
-Hannah
-Chalcol
-Elienai
-Nobah
-Hushim
-Sabtechah
-Agee
-Ismaiah
-Adina
-Isshijah
-Zalmon
-Abiasaph
-Shagee
-Chislon
diff --git a/hw/hw2/starter-code/hw2-q3.dl b/hw/hw2/starter-code/hw2-q3.dl
deleted file mode 100644
index 36a169feb785da384bbff01c27157c03be5c2c7c..0000000000000000000000000000000000000000
--- a/hw/hw2/starter-code/hw2-q3.dl
+++ /dev/null
@@ -1,27 +0,0 @@
-/************ data model **************/
-.symbol_type PersonType
-.symbol_type DescriptionType
-
-.decl person(name:PersonType, description:DescriptionType)
-.input person(filename="DATA/person.facts")
-
-.decl female(name:PersonType)
-.input female(filename="DATA/female.facts")
-
-.decl male(name:PersonType)
-.input male(filename="DATA/male.facts")
-
-.decl parent_child(p1:PersonType, p2:PersonType)
-.input parent_child(filename="DATA/parent_child.facts")
-
-.decl person_living(p:PersonType)
-.input person_living(filename="DATA/person_living.facts")
-
-/************* problem 0 **************/
-/**** Find all children of Priscilla ****/
-.decl p0(x:PersonType, d:DescriptionType)
-// NOTE: if you want to redirect the output to a file
-// you can use the syntax:
-// .output p0(filename="hw2-q3-0.ans")
-.output p0(IO=stdout)
-p0(x,d) :- parent_child("Priscilla",x), person(x,d).
diff --git a/hw/hw2/submission/README b/hw/hw2/submission/README
deleted file mode 100644
index 01cd877bb5c5ca946c55e2f366181cd6207eb94b..0000000000000000000000000000000000000000
--- a/hw/hw2/submission/README
+++ /dev/null
@@ -1 +0,0 @@
-put your .sql and .txt files in this directory, one file per question.
diff --git a/hw/hw3/hw3.md b/hw/hw3/hw3.md
deleted file mode 100644
index 0f24a8d813898374a80db02dc947e653ab4d32f0..0000000000000000000000000000000000000000
--- a/hw/hw3/hw3.md
+++ /dev/null
@@ -1,954 +0,0 @@
-CSE 544 Homework 3: SimpleDB
-============================
-
-**Objectives:**
-
-To get experience implementing the internals of a DBMS.
-
-**Assignment tools:**
-
-apache ant and your favorite code editor
-
-**Assigned date:** Jan 28, 2018
-
-**Due date:** Feb. 16, 2018
-
-**What to turn in:**
-
-See below.
-
-**Starter code:**
-
-In your `hw/hw3/starter-code` folder
-
-Acknowledgement
----------------
-
-This assignment comes from Prof. Sam Madden's 6.830 class at MIT.
-
-The full series of SimpleDB assignments includes what we will do in this
-homework, which is to build the basic functionality for query
-processing. It also includes transactions and query optimization, which
-we will NOT do.
-
-We also use this series of assignments in [CSE
-444](http://courses.cs.washington.edu/courses/cse444/). We have
-contributed bug fixes and an extra lab to SimpleDB. The lab that we
-added involves building a parallel, shared-nothing version of SimpleDB.
-We invite you to take a look at the CSE 444 course webpage to see what
-all the SimpleDB labs are about.
-
-
-Assignment goal
----------------
-
-In this assignment, you will write a basic database management system
-called SimpleDB. First, you will implement the core modules required to
-access stored data on disk. You will then write a set of operators for
-SimpleDB to implement selections, joins, and aggregates. The end result
-is a database system that can perform simple queries over multiple
-tables. We will not ask you to add transactions, locking, and concurrent
-queries because we do not have time to do the full project in 544.
-However, we invite you to think how you would add such functionality
-into the system.
-
-SimpleDB is written in Java. We have provided you with a set of mostly
-unimplemented classes and interfaces. You will need to write the code
-for these classes. We will grade your code by running a set of system
-tests written using [JUnit](http://www.junit.org/). We have also
-provided a number of unit tests, which we will not use for grading but
-that you may find useful in verifying that your code works. Note that
-the unit tests we provide are to help guide your implementation along,
-but they are not intended to be comprehensive or to establish
-correctness.
-
-The remainder of this document describes the basic architecture of
-SimpleDB, gives some suggestions about how to start coding, and
-discusses how to hand in your assignment.
-
-We **strongly recommend** that you start as early as possible on this
-assignment. It requires you to write a fair amount of code!
-
-0. Find bugs, be patient, earn candy bars
------------------------------------------
-
-SimpleDB is a relatively complex piece of code. It is very possible you
-are going to find bugs, inconsistencies, and bad, outdated, or incorrect
-documentation, etc.
-
-We ask you, therefore, to do this assignment with an adventurous
-mindset. Don't get mad if something is not clear, or even wrong; rather,
-try to figure it out yourself or send us a friendly email. We promise to
-help out by posting bug fixes, new tarballs, etc., as bugs and issues
-are reported.
-
-1. Getting started
-------------------
-
-These instructions are written for any Unix-based platform (e.g., Linux,
-MacOS, etc.). Because the code is written in Java, it should work under
-Windows as well, though the directions in this document may not apply.
-
-We have included Section 1.2 on using the project with Eclipse and Intellij. Using
-those IDEs is recommended, especially if you are on Windows.
-
-Pull the latest changes from upstream to your local master branch
-(the upstream is the one you added in
-[hw1](https://gitlab.cs.washington.edu/suciu/cse544-2018wi/blob/master/hw/hw1/hw1.md))
-
-```bash
-$ git pull upstream master
-```
-
-SimpleDB uses the [Ant build tool](http://ant.apache.org/) to compile
-the code and run tests. Ant is similar to
-[make](http://www.gnu.org/software/make/manual/), but the build file is
-written in XML and is somewhat better suited to Java code. Most modern
-Linux distributions include Ant.
-
-To help you during development, we have provided a set of unit tests in
-addition to the end-to-end tests that we use for grading. These are by
-no means comprehensive, and you should not rely on them exclusively to
-verify the correctness of your project.
-
-To run the unit tests use the test build target:
-
-```bash
-$ cd hw/hw3/starter-code
-$ # run all unit tests
-$ ant test
-$ # run a specific unit test
-$ ant runtest -Dtest=TupleTest
-```
-
-You should see output similar to:
-
-```bash
-# build output...
-
-test:
- [junit] Running simpledb.TupleTest
- [junit] Testsuite: simpledb.TupleTest
- [junit] Tests run: 3, Failures: 0, Errors: 3, Time elapsed: 0.036 sec
- [junit] Tests run: 3, Failures: 0, Errors: 3, Time elapsed: 0.036 sec
-
-# ... stack traces and error reports ...
-```
-
-The output above indicates that three errors occurred during
-compilation; this is because the code we have given you doesn't yet
-work. As you complete parts of the assignment, you will work towards
-passing additional unit tests. If you wish to write new unit tests as
-you code, they should be added to the test/simpledb directory.
-
-For more details about how to use Ant, see the
-[manual](http://ant.apache.org/manual/). The [Running
-Ant](http://ant.apache.org/manual/running.html) section provides details
-about using the ant command. However, the quick reference table below
-should be sufficient for working on the assignments.
-
- - `ant` Build the default target (for simpledb, this is dist).
- - `ant eclipse` Make the project an Eclipse project.
- - `ant -projecthelp` List all the targets in `build.xml` with descriptions.
- - `ant dist` Compile the code in src and package it in `dist/simpledb.jar`.
- - `ant test` Compile and run all the unit tests.
- - `ant runtest -Dtest=testname` Run the unit test named `testname`.
- - `ant systemtest` Compile and run all the system tests.
- - `ant runsystest -Dtest=testname` Compile and run the system test named `testname`.
-
-### 1.1. Running end-to-end tests
-
-We have also provided a set of end-to-end tests that will eventually be
-used for grading. These tests are structured as JUnit tests that live in
-the test/simpledb/systemtest directory. To run all the system tests, use
-the systemtest build target:
-
-```bash
-$ ant systemtest
-
-# ... build output ...
-
-systemtest:
-
-[junit] Running simpledb.systemtest.ScanTest
- [junit] Testsuite: simpledb.systemtest.ScanTest
- [junit] Tests run: 3, Failures: 0, Errors: 3, Time elapsed: 0.237 sec
- [junit] Tests run: 3, Failures: 0, Errors: 3, Time elapsed: 0.237 sec
- [junit]
- [junit] Testcase: testSmall took 0.017 sec
- [junit] Caused an ERROR
- [junit] implement this
- [junit] java.lang.UnsupportedOperationException: implement this
- [junit] at simpledb.HeapFile.id(HeapFile.java:46)
- [junit] at simpledb.systemtest.SystemTestUtil.matchTuples(SystemTestUtil.java:90)
- [junit] at simpledb.systemtest.SystemTestUtil.matchTuples(SystemTestUtil.java:83)
- [junit] at simpledb.systemtest.ScanTest.validateScan(ScanTest.java:30)
- [junit] at simpledb.systemtest.ScanTest.testSmall(ScanTest.java:41)
-
-# ... more error messages ...
-```
-
-This indicates that this test failed, showing the stack trace where the
-error was detected. To debug, start by reading the source code where the
-error occurred. When the tests pass, you will see something like the
-following:
-
-```bash
-$ ant systemtest
-
-# ... build output ...
-
- [junit] Testsuite: simpledb.systemtest.ScanTest
- [junit] Tests run: 3, Failures: 0, Errors: 0, Time elapsed: 7.278 sec
- [junit] Tests run: 3, Failures: 0, Errors: 0, Time elapsed: 7.278 sec
- [junit]
- [junit] Testcase: testSmall took 0.937 sec
- [junit] Testcase: testLarge took 5.276 sec
- [junit] Testcase: testRandom took 1.049 sec
-
-BUILD SUCCESSFUL
-Total time: 52 seconds
-```
-
-### 1.1.1 Creating dummy tables
-
-It is likely you'll want to create your own tests and your own data
-tables to test your own implementation of SimpleDB. You can create any
-.txt file and convert it to a .dat file in SimpleDB's HeapFile format
-using the command:
-
-```bash
-$ ant dist
-
-$ java -jar dist/simpledb.jar convert file.txt N
-```
-
-where file.txt is the name of the file and N is the number of columns in
-the file. Notice that file.txt has to be in the following format:
-
-```
-int1,int2,...,intN
-int1,int2,...,intNint1,int2,...,intN
-int1,int2,...,intN
-```
-
-...where each intN is a non-negative integer.
-
-To view the contents of a table, use the print command. Note that this
-command will not work until later in the assignment:
-
-```bash
-$ java -jar dist/simpledb.jar print file.dat N
-```
-
-where file.dat is the name of a table created with the convert command,
-and N is the number of columns in the file.
-
-### 1.1.2 Debugging
-
-You can get some debug messages printed out while running tests if you
-add
-
- -Dsimpledb.Debug
-
-as one of the arguments to the Java VM.
-
-
-### 1.2. Working in Eclipse and Intellij(Optional)
-
-IDEs like [Eclipse](http://www.eclipse.org/) or [Intellij](https://www.jetbrains.com/idea/)
-is a graphical software development
-environment that you might be more comfortable with working in.
-
-**Setting the Assignment Up in Eclipse**
-
-- `cd hw/hw3/starter-code` and then run `ant eclipse`
-- With Eclipse running, select File-\>Open Projects from File System
- (or File-\>Import, select "Existing Projects into Workspace" under "General")
-- Select the starter-code folder. It should contain build.xml.
-- Click Finish, and you should be able to see "simpledb" as a new project
- in the Project Explorer tab on the left-hand side of your screen (if
- you just installed Eclipse, make sure to close the "Welcome"
- window). Opening this project reveals the directory structure
- discussed above - implementation code can be found in "src," and
- unit tests and system tests found in "test."
-
-**Setting the Assignment Up in Intellij**
-
-- `cd hw/hw3/starter-code` and then run `ant eclipse` (The TA is too lazy to
- create a separate ant target for Intellij, so we are just going to import
- the Eclipse project into the Intellij)
-- Open Intellij, and select "Import Project" if you are in the startup panel,
- or go to File-\>New-\>Project from Existing Sources
-- Select the starter-code folder then hit "OK"
-- On the first prompt window, make sure "Eclipse" is selected
-- Hit "Next" until no more prompt windows showing up. Leave all the suggested
- options as-is
-
-**Running Individual Unit and System Tests**
-
-To run a unit test or system test (both are JUnit tests, and can be
-initialized the same way), go to the Package Explorer tab on the left
-side of your screen. In your IDE, open the "test" directory.
-Unit tests are found in the "simpledb" package, and system tests are
-found in the "simpledb.systemtests" package. To run one of these tests,
-select the test (they are all called `\*Test.java` - don't select
-`TestUtil.java` or `SystemTestUtil.java`), right click on it, in Eclipse,
-select "Run As," and select "JUnit Test." In Intellij, simply select the
-"Run '...Test.java'" option. This will bring up a JUnit tab, which will
-tell you the status of the individual tests within the JUnit test suite,
-and will show you exceptions and other errors that will help you debug
-problems.
-
-**Running Ant Build Targets**
-
-If you want to run commands such as `ant test` or `ant systemtest`,
-- In Eclipse:
- - right click on build.xml in the Package Explorer.
- - Select "Run As" and then "Ant Build..." (note: select the option with the ellipsis (...),
- otherwise you won't be presented with a set of build targets to run).
- - Then, in the "Targets" tab of the next screen, check off the targets you
- want to run (probably "dist" and one of "test" or "systemtest"). This
- should run the build targets and show you the results in Eclipse's
- console window.
-- In Intellij:
- - right click on build.xml in the Package Explorer.
- - Select "Add as Ant Build File"
- - Now you should be able to see the available commands on the Ant Build panel
-
-
-### 1.3. Implementation hints
-
-Before beginning to write code, we **strongly encourage** you to read
-through this entire document to get a feel for the high-level design of
-SimpleDB.
-
-You will need to fill in any piece of code that is not implemented. It
-will be obvious where we think you should write code. You may need to
-add private methods and/or helper classes. You may change APIs, but make
-sure our grading tests still run and make sure to mention, explain, and
-defend your decisions in your writeup.
-
-In addition to the methods that you need to fill out for this
-assignment, the class interfaces contain numerous methods that you need
-not implement in this assignment. These will either be indicated per
-class:
-
-```java
-// Not necessary for this assignment
-public class Insert implements DbIterator {
-```
-
-or per method:
-
-```java
-public boolean deleteTuple(Tuple t) throws DbException {
-
- // Not necessary for this assignment
- return false;
-}
-```
-
-The code that you submit should compile without having to modify these
-methods.
-
-We suggest exercises along this document to guide your implementation,
-but you may find that a different order makes more sense for you. Here's
-a rough outline of one way you might proceed with your SimpleDB
-implementation:
-
-- Implement the classes to manage tuples, namely `Tuple`, `TupleDesc`. We
- have already implemented `Field`, `IntField`, `StringField`, and `Type` for
- you. Since you only need to support integer and (fixed length)
- string fields and fixed length tuples, these are straightforward.
-- Implement the `Catalog` (this should be very simple).
-- Implement the `BufferPool` constructor and the `getPage()` method.
-- Implement the access methods, `HeapPage` and `HeapFile` and associated
- ID classes. A good portion of these files has already been written
- for you.
-- Implement the operator `SeqScan`.
-- At this point, you should be able to pass the `ScanTest system test`.
-- Implement the operators `Filter` and `Join` and verify
- that their corresponding tests work. The Javadoc comments for these
- operators contain details about how they should work. We have given
- you implementations of `Project` and `OrderBy` which
- may help you understand how other operators work.
-- (Extra credit) Implement `IntAggregator` and
- `StringAggregator`. Here, you will write the logic that
- actually computes an aggregate over a particular field across
- multiple groups in a sequence of input tuples. Use integer division
- for computing the average, since SimpleDB only supports integers.
- `StringAggegator` only needs to support the `COUNT` aggregate, since the
- other operations do not make sense for strings.
-- (Extra credit) Implement the `Aggregate` operator. As with
- other operators, aggregates implement the `DbIterator`
- interface so that they can be placed in SimpleDB query plans. Note
- that the output of an `Aggregate` operator is an aggregate
- value of an entire group for each call to `next()`, and that
- the aggregate constructor takes the aggregation and grouping fields.
-- (Extra credit) Use thre provided parse to run some queries, and
- report your query execution times.
-
-At this point you should be able to pass all of the tests in the ant
-`systemtest` target, which is the goal of this homework. Section
-2 below walks you through these implementation steps and the unit tests
-corresponding to each one in more detail.
-
-### 1.4. Transactions, locking, and recovery
-
-As you look through the interfaces that we have provided you, you will
-see a number of references to locking, transactions, and recovery. You
-do not need to support these features. We will not be implementing this
-part of SimpleDB in 544. The test code we have provided you with
-generates a fake transaction ID that is passed into the operators of the
-query it runs; you should pass this transaction ID into other operators
-and the buffer pool.
-
-2. SimpleDB Architecture and Implementation Guide
--------------------------------------------------
-
-SimpleDB consists of:
-
-- Classes that represent fields, tuples, and tuple schemas;
-- Classes that apply predicates and conditions to tuples;
-- One or more access methods (e.g., heap files) that store relations
- on disk and provide a way to iterate through tuples of those
- relations;
-- A collection of operator classes (e.g., select, join, insert,
- delete, etc.) that process tuples;
-- A buffer pool that caches active tuples and pages in memory and
- handles concurrency control and transactions (neither of which you
- need to worry about for this homework); and,
-- A catalog that stores information about available tables and their
- schemas.
-
-SimpleDB does not include many things that you may think of as being a
-part of a "database." In particular, SimpleDB does not have:
-
-- A SQL front end or parser that allows you to type queries directly
- into SimpleDB. Instead, queries are built up by chaining a set of
- operators together into a hand-built query plan (see [Section
- 2.7](#query_walkthrough)). We will provide a simple parser for use
- if you like to work on the extra credit problems (see below).
-- Views.
-- Data types except integers and fixed length strings.
-- Query optimizer.
-- Indices.
-
-In the rest of this Section, we describe each of the main components of
-SimpleDB that you will need to implement in this homework. You should
-use the exercises in this discussion to guide your implementation. This
-document is by no means a complete specification for SimpleDB; you will
-need to make decisions about how to design and implement various parts
-of the system.
-
-### 2.1. The Database Class
-
-The Database class provides access to a collection of static objects
-that are the global state of the database. In particular, this includes
-methods to access the catalog (the list of all the tables in the
-database), the buffer pool (the collection of database file pages that
-are currently resident in memory), and the log file. You will not need
-to worry about the log file in this homework. We have implemented the
-Database class for you. You should take a look at this file as you will
-need to access these objects.
-
-### 2.2. Fields and Tuples
-
-Tuples in SimpleDB are quite basic. They consist of a collection of
-`Field` objects, one per field in the `Tuple`. `Field` is an interface
-that different data types (e.g., integer, string) implement. `Tuple`
-objects are created by the underlying access methods (e.g., heap files,
-or B-trees), as described in the next section. Tuples also have a type
-(or schema), called a *tuple descriptor*, represented by a `TupleDesc`
-object. This object consists of a collection of `Type` objects, one per
-field in the tuple, each of which describes the type of the
-corresponding field.
-
-**Exercise 1.** Implement the skeleton methods in:
-
-- `src/java/simpledb/TupleDesc.java`
-- `src/java/simpledb/Tuple.java`
-
-At this point, your code should pass the unit tests `TupleTest` and
-`TupleDescTest`. At this point, `modifyRecordId()` should fail because you
-havn't implemented it yet.
-
-### 2.3. Catalog
-
-The catalog (class `Catalog` in SimpleDB) consists of a list of the
-tables and schemas of the tables that are currently in the database. You
-will need to support the ability to add a new table, as well as getting
-information about a particular table. Associated with each table is a
-`TupleDesc` object that allows operators to determine the types and
-number of fields in a table.
-
-The global catalog is a single instance of `Catalog` that is allocated
-for the entire SimpleDB process. The global catalog can be retrieved via
-the method `Database.getCatalog()`, and the same goes for the global
-buffer pool (using `Database.getBufferPool()`).
-
-**Exercise 2.** Implement the skeleton methods in:
-
-- `src/java/simpledb/Catalog.java`
-
-At this point, your code should pass the unit tests in `CatalogTest`.
-
-### 2.4. BufferPool
-
-The buffer pool (class `BufferPool` in SimpleDB) is responsible for
-caching pages in memory that have been recently read from disk. All
-operators read and write pages from various files on disk through the
-buffer pool. It consists of a fixed number of pages, defined by the
-`numPages` parameter to the `BufferPool` constructor. For this homework,
-implement the constructor and the `BufferPool.getPage()` method used by
-the `SeqScan` operator. The BufferPool should store up to `numPages`
-pages. If more than `numPages` requests are made for different pages,
-then instead of implementing an eviction policy, you may throw a
-`DbException`.
-
-The `Database` class provides a static method,
-`Database.getBufferPool()`, that returns a reference to the single
-BufferPool instance for the entire SimpleDB process.
-
-**Exercise 3.** Implement the `getPage()` method in:
-
-- `src/java/simpledb/BufferPool.java`
-
-We have not provided unit tests for BufferPool. The functionality you
-implemented will be tested in the implementation of HeapFile below. You
-should use the `DbFile.readPage` method to access pages of a DbFile.
-
-### 2.5. HeapFile access method
-
-Access methods provide a way to read or write data from disk that is
-arranged in a specific way. Common access methods include heap files
-(unsorted files of tuples) and B-trees; for this assignment, you will
-only implement a heap file access method, and we have written some of
-the code for you.
-
-A `HeapFile` object is arranged into a set of pages, each of which
-consists of a fixed number of bytes for storing tuples, (defined by the
-constant `BufferPool.PAGE_SIZE`), including a header. In SimpleDB, there
-is one `HeapFile` object for each table in the database. Each page in a
-`HeapFile` is arranged as a set of slots, each of which can hold one
-tuple (tuples for a given table in SimpleDB are all of the same size).
-In addition to these slots, each page has a header that consists of a
-bitmap with one bit per tuple slot. If the bit corresponding to a
-particular tuple is 1, it indicates that the tuple is valid; if it is 0,
-the tuple is invalid (e.g., has been deleted or was never initialized.)
-Pages of `HeapFile` objects are of type `HeapPage` which implements the
-`Page` interface. Pages are stored in the buffer pool but are read and
-written by the `HeapFile` class.
-
-SimpleDB stores heap files on disk in more or less the same format they
-are stored in memory. Each file consists of page data arranged
-consecutively on disk. Each page consists of one or more bytes
-representing the header, followed by the
-`BufferPool.PAGE_SIZE - # header bytes ` bytes of actual page content.
-Each tuple requires *tuple size* \* 8 bits for its content and 1 bit for
-the header. Thus, the number of tuples that can fit in a single page is:
-
-` tupsPerPage = floor((BufferPool.PAGE_SIZE * 8) / (tuple size * 8 + 1))`
-
-Where *tuple size* is the size of a tuple in the page in bytes. The idea
-here is that each tuple requires one additional bit of storage in the
-header. We compute the number of bits in a page (by mulitplying
-`PAGE_SIZE` by 8), and divide this quantity by the number of bits in a
-tuple (including this extra header bit) to get the number of tuples per
-page. The floor operation rounds down to the nearest integer number of
-tuples (we don't want to store partial tuples on a page!)
-
-Once we know the number of tuples per page, the number of bytes required
-to store the header is simply:
-
-` headerBytes = ceiling(tupsPerPage/8)`
-
-The ceiling operation rounds up to the nearest integer number of bytes
-(we never store less than a full byte of header information.)
-
-The low (least significant) bits of each byte represents the status of
-the slots that are earlier in the file. Hence, the lowest bit of the
-first byte represents whether or not the first slot in the page is in
-use. Also, note that the high-order bits of the last byte may not
-correspond to a slot that is actually in the file, since the number of
-slots may not be a multiple of 8. Also note that all Java virtual
-machines are [big-endian](http://en.wikipedia.org/wiki/Endianness).
-
-**Exercise 4.** Implement the skeleton methods in:
-
-- `src/java/simpledb/HeapPageId.java`
-- `src/java/simpledb/RecordId.java`
-- `src/java/simpledb/HeapPage.java`
-
-Although you will not use them directly in this lab, we ask you to
-implement `getNumEmptySlots()` and `isSlotUsed()` in `HeapPage`. These
-require pushing around bits in the page header. You may find it helpful
-to look at the other methods that have been provided in `HeapPage` or in
-`src/java/simpledb/HeapFileEncoder.java` to understand the layout of
-pages.
-
-You will also need to implement an Iterator over the tuples in the page,
-which may involve an auxiliary class or data structure.
-
-At this point, your code should pass the unit tests in `HeapPageIdTest`,
-`RecordIdTest`, and `HeapPageReadTest`.
-
-After you have implemented `HeapPage`, you will write methods for
-`HeapFile` in this homework to calculate the number of pages in a file
-and to read a page from the file. You will then be able to fetch tuples
-from a file stored on disk.
-
-**Exercise 5.** Implement the skeleton methods in:
-
-- `src/java/simpledb/HeapFile.java`
-
-To read a page from disk, you will first need to calculate the correct
-offset in the file. Hint: you will need random access to the file in
-order to read and write pages at arbitrary offsets. You should not call
-BufferPool methods when reading a page from disk.
-
-You will also need to implement the `HeapFile.iterator()` method, which
-should iterate through through the tuples of each page in the HeapFile.
-The iterator must use the `BufferPool.getPage()` method to access pages
-in the `HeapFile`. This method loads the page into the buffer pool. Do
-not load the entire table into memory on the `open()` call -- this will
-cause an out of memory error for very large tables.
-
-At this point, your code should pass the unit tests in `HeapFileReadTest`.
-
-### 2.6. Operators
-
-Operators are responsible for the actual execution of the query plan.
-They implement the operations of the relational algebra. In SimpleDB,
-operators are iterator based; each operator implements the `DbIterator`
-interface.
-
-Operators are connected together into a plan by passing lower-level
-operators into the constructors of higher-level operators, i.e., by
-'chaining them together.' Special access method operators at the leaves
-of the plan are responsible for reading data from the disk (and hence do
-not have any operators below them).
-
-At the top of the plan, the program interacting with SimpleDB simply
-calls `getNext` on the root operator; this operator then calls `getNext`
-on its children, and so on, until these leaf operators are called. They
-fetch tuples from disk and pass them up the tree (as return arguments to
-`getNext`); tuples propagate up the plan in this way until they are
-output at the root or combined or rejected by another operator in the
-plan.
-
-#### 2.6.1. Scan
-
-**Exercise 6.** Implement the skeleton methods in:
-
-- `src/java/simpledb/SeqScan.java`
-
-This operator sequentially scans all of the tuples from the pages of the
-table specified by the `tableid` in the constructor. This operator
-should access tuples through the `DbFile.iterator()` method.
-
-At this point, you should be able to complete the `ScanTest` system test.
-Good work!
-
-#### 2.6.2. Filter and Join
-
-Recall that SimpleDB DbIterator classes implement the operations of the
-relational algebra. You will now implement two operators that will
-enable you to perform queries that are slightly more interesting than a
-table scan.
-
-- *Filter*: This operator only returns tuples that satisfy a
- `Predicate` that is specified as part of its constructor. Hence, it
- filters out any tuples that do not match the predicate.
-- *Join*: This operator joins tuples from its two children according
- to a `JoinPredicate` that is passed in as part of its constructor.
- We only require a simple nested loops join, but you may explore more
- interesting join implementations. Describe your implementation in
- your writeup.
-
-**Exercise 7.** Implement the skeleton methods in:
-
-- `src/simpledb/Predicate.java`
-- `src/simpledb/JoinPredicate.java`
-- `src/simpledb/Filter.java`
-- `src/simpledb/Join.java`
-
-At this point, your code should pass the unit tests in `PredicateTest`,
-`JoinPredicateTest`, `FilterTest`, and `JoinTest`. Furthermore, you should be
-able to pass the system tests `FilterTest` and `JoinTest`.
-
-#### 2.6.3. Aggregates (EXTRA CREDIT)
-
-**All the materials in this section is optional and will count only as
-extra credit.**
-
-An additional SimpleDB operator implements basic SQL aggregates with a
-`GROUP BY` clause. You should implement the five SQL aggregates
-(`COUNT`, `SUM`, `AVG`, `MIN`, `MAX`) and support grouping. You only
-need to support aggregates over a single field, and grouping by a single
-field.
-
-In order to calculate aggregates, we use an `Aggregator` interface which
-merges a new tuple into the existing calculation of an aggregate. The
-`Aggregator` is told during construction what operation it should use
-for aggregation. Subsequently, the client code should call
-`Aggregator.mergeTupleIntoGroup()` for every tuple in the child
-iterator. After all tuples have been merged, the client can retrieve a
-DbIterator of aggregation results. Each tuple in the result is a pair of
-the form `(groupValue, aggregateValue)`, unless the value of the group
-by field was `Aggregator.NO_GROUPING`, in which case the result is a
-single tuple of the form `(aggregateValue)`.
-
-Note that this implementation requires space linear in the number of
-distinct groups. For the purposes of this homework, you do not need to
-worry about the situation where the number of groups exceeds available
-memory.
-
-**Exercise 8.** Implement the skeleton methods in:
-
-- `src/simpledb/IntegerAggregator.java`
-- `src/simpledb/StringAggregator.java`
-- `src/simpledb/Aggregate.java`
-
-At this point, your code should pass the unit tests
-`IntegerAggregatorTest`, `StringAggregatorTest`, and `AggregateTest`.
-Furthermore, you should be able to pass the `AggregateTest` system test.
-
-### 2.7. Query Parser and Contest (EXTRA CREDIT)
-
-**All the materials in this section is optional and will count only as
-extra credit.**
-
-We've provided you with a query parser for SimpleDB that you can use to
-write and run SQL queries against your database once you have completed
-the exercises in this homework.
-
-The first step is to create some data tables and a catalog. Suppose you
-have a file `data.txt` with the following contents:
-
- 1,10
- 2,20
- 3,30
- 4,40
- 5,50
- 5,50
-
-You can convert this into a SimpleDB table using the `convert` command
-(make sure to type `ant` first!):
-
- java -jar dist/simpledb.jar convert data.txt 2 "int,int"
-
-This creates a file `data.dat`. In addition to the table's raw data, the
-two additional parameters specify that each record has two fields and
-that their types are `int` and `int`.
-
-Next, create a catalog file, `catalog.txt`, with the follow contents:
-
- data (f1 int, f2 int)
-
-This tells SimpleDB that there is one table, `data` (stored in
-`data.dat`) with two integer fields named `f1` and `f2`.
-
-Finally, invoke the parser. You must run java from the command line (ant
-doesn't work properly with interactive targets.) From the `simpledb/`
-directory, type:
-
- java -jar dist/simpledb.jar parser catalog.txt
-
-You should see output like:
-
- Added table : data with schema INT(f1), INT(f2),
- SimpleDB>
-
-Finally, you can run a query:
-
- SimpleDB> select d.f1, d.f2 from data d;
- Started a new transaction tid = 1221852405823
- ADDING TABLE d(data) TO tableMap
- TABLE HAS tupleDesc INT(d.f1), INT(d.f2),
- 1 10
- 2 20
- 3 30
- 4 40
- 5 50
- 5 50
-
- 6 rows.
- ----------------
- 0.16 seconds
-
- SimpleDB>
-
-The parser is relatively full featured (including support for SELECTs,
-INSERTs, DELETEs, and transactions), but does have some problems and
-does not necessarily report completely informative error messages. Here
-are some limitations to bear in mind:
-
-- You must preface every field name with its table name, even if the
- field name is unique (you can use table name aliases, as in the
- example above, but you cannot use the AS keyword.)
-- Nested queries are supported in the WHERE clause, but not the FROM
- clause.
-- No arithmetic expressions are supported (for example, you can't take
- the sum of two fields.)
-- At most one GROUP BY and one aggregate column are allowed.
-- Set-oriented operators like IN, UNION, and EXCEPT are not allowed.
-- Only AND expressions in the WHERE clause are allowed.
-- UPDATE expressions are not supported.
-- The string operator LIKE is allowed, but must be written out fully
- (that is, the Postgres tilde [\~] shorthand is not allowed.)
-
-**Exercise 9: Please execute the three queries below using your SimpleDB
-prototype and report the times in your homework write-up.**
-
-We have built a SimpleDB-encoded version of the DBLP database; the
-needed files are located at:
-[http://www.cs.washington.edu/education/courses/cse544/15au/hw/hw2/dblp\_data.tar.gz](http://www.cs.washington.edu/education/courses/cse544/15au/hw/hw2/dblp_data.tar.gz)
-
-You should download the file and unpack it. It will create four files in
-the `dblp_data` directory. Move them into the `simpledb` directory. The
-following commands will acomplish this, if you run them from the
-`simpledb` directory:
-
-```bash
- $ wget http://www.cs.washington.edu/education/courses/cse544/15au/hw/hw2/dblp_data.tar.gz
- $ tar xvzf dblp_data.tar.gz
- $ mv dblp_data/* .
- $ rm -r dblp_data.tar.gz dblp_data
-```
-
-You can then run the parser with:
-```bash
- $ java -jar dist/simpledb.jar parser dblp_simpledb.schema
-```
-We will start a thread on the course message board inviting anyone
-interested to post their runtimes for the following three queries
-(please run the queries on a lab machine and indicate which one you used
-so it becomes easier to compare runtimes). The contest is just for fun.
-It will not affect your grade:
-
-1.
-
- SELECT p.title
- FROM papers p
- WHERE p.title LIKE 'selectivity';
-
-2.
-
- SELECT p.title, v.name
- FROM papers p, authors a, paperauths pa, venues v
- WHERE a.name = 'E. F. Codd'
- AND pa.authorid = a.id
- AND pa.paperid = p.id
- AND p.venueid = v.id;
-
-3.
-
- SELECT a2.name, count(p.id)
- FROM papers p, authors a1, authors a2, paperauths pa1, paperauths pa2
- WHERE a1.name = 'Michael Stonebraker'
- AND pa1.authorid = a1.id
- AND pa1.paperid = p.id
- AND pa2.authorid = a2.id
- AND pa1.paperid = pa2.paperid
- GROUP BY a2.name
- ORDER BY a2.name;
-
-
-Note that each query will print out its runtime after it executes.
-
-You may wish to create optimized implementations of some of the
-operators; in particular, a fast join operator (e.g., not nested loops)
-will be essential for good performance on queries 2 and 3.
-
-There is currently no optimizer in the parser, so the queries above have
-been written to cause the parser to generate reasonable plans. Here are
-some helpful hints about how the parser works that you may wish to
-exploit while running these queries:
-
-- The table on the left side of the joins in these queries is passed
- in as the first `DbIterator` parameter to `Join`.
-- Expressions in the WHERE clause are added to the plan from top to
- bottom, such that first expression will be the bottom-most operator
- in the generated query plan. For example, the generated plan for
- Query 2 is:
-
- Project(Join(Join(Filter(a),pa),p))
-
-Our reference implementation can run Query 1 in about .35 seconds, Query
-2 in about 10 seconds, and Query 3 in about 20 seconds. We implemented a
-special-purpose join operator for equality joins but did little else to
-optimize performance. Actual runtimes might vary depending on your
-machine setting.
-
-Depending on the efficiency of your implementation, each of these
-queries will take seconds to minutes to run to completion, outputting
-tuples as they are computed. Certainly don't expect the level of
-performance of postgres. :)
-
-Turn in instructions
---------------------
-
-You must submit your code (see below) as well as a short (2 pages,
-maximum) writeup file called `writeup.txt` describing your approach. This writeup should:
-
-- Describe any design decisions you made. For example any class or
- complex data structure you add to the project. If you used something
- other than a nested-loops join, describe the tradeoffs of the
- algorithm you chose.
-- Discuss and justify any changes you made to the API.
-- Describe any missing or incomplete elements of your code.
-- Describe how long you spent on the assignment, and whether there was
- anything you found particularly difficult or confusing.
-
-Put all your code as well as the `writeup.txt` file in the `starter-code` folder.
-and run the `turnInHw.sh` script:
-```bash
-# also remember to add the writeup.txt!!
-$ ./turnInHw.sh hw3
-```
-
-Submitting a bug
-----------------
-
-Please submit (friendly!) bug reports to the TA and instructor. When you
-do, please try to include:
-
-- A description of the bug.
-- A .java file we can drop in the test/simpledb directory, compile,
- and run.
-- A .txt file with the data that reproduces the bug. We should be able
- to convert it to a .dat file using HeapFileEncoder.
-
-Grading
--------
-
-50% of your grade will be based on whether or not your code passes the
-system test suite we will run over it. These tests will be a superset of
-the tests we have provided. Before handing in your code, you should make
-sure it produces no errors (passes all of the tests) from both ant test
-and ant systemtest.
-
-**Important**: before testing, we will replace your build.xml,
-`HeapFileEncoder.java`, and the entire contents of the test directory
-with our version of these files. This means you cannot change the format
-of .dat files! You should also be careful changing our APIs. You should
-test that your code compiles the unmodified tests. In other words, we
-will untar your tarball, replace the files mentioned above, compile it,
-and then grade it. It will look roughly like this:
-
-```bash
-$ cd ./hw3/starter-code[replace build.xml, HeapFileEncoder.java, and test]
-$ ant test
-$ ant systemtest
-[additional tests]
-```
-
-An additional 50% of your grade will be based on the quality of your
-writeup and our subjective evaluation of your code.
-
-Extra credit: 2% for each.
-
-We hope you will enjoy this assignment and will learn a lot about how a
-simple DBMS system can be implemented!
diff --git a/hw/hw3/starter-code/.gitignore b/hw/hw3/starter-code/.gitignore
deleted file mode 100644
index c63eb4c14fd83ef674e512858cd63d5d7327faaf..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/.gitignore
+++ /dev/null
@@ -1,9 +0,0 @@
-*.iml
-.classpath
-.project
-bin/
-out/
-.idea/
-log
-*.dat
-dblp_simpledb.schema
\ No newline at end of file
diff --git a/hw/hw3/starter-code/build.xml b/hw/hw3/starter-code/build.xml
deleted file mode 100644
index cb0258a8592b91333aa53930a31c630e5cc940bd..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/build.xml
+++ /dev/null
@@ -1,309 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name="simpledb" default="dist" basedir=".">
- <property name="src" location="src"/>
- <property name="testd" location="test"/>
-
- <property name="build" location="bin"/>
- <property name="build.src" location="${build}/src"/>
- <property name="build.test" location="${build}/test"/>
- <property name="depcache" location="${build}/depcache"/>
-
- <property name="lib" location="lib"/>
- <property name="doc" location="javadoc"/>
- <property name="dist" location="dist"/>
- <property name="jarfile" location="${dist}/${ant.project.name}.jar"/>
- <property name="compile.debug" value="true"/>
- <property name="test.reports" location="testreport"/>
-
- <property name="sourceversion" value="1.7"/>
-
- <path id="classpath.base">
- <pathelement location="${build.src}"/>
- <pathelement location="${lib}/zql.jar"/>
- <pathelement location="${lib}/jline-0.9.94.jar"/>
- <pathelement location="${lib}/mina-core-2.0.4.jar"/>
- <pathelement location="${lib}/mina-filter-compression-2.0.4.jar"/>
- <pathelement location="${lib}/slf4j-api-1.6.1.jar"/>
- <pathelement location="${lib}/slf4j-log4j12-1.6.1.jar"/>
- <pathelement location="${lib}/log4j-1.2.17.jar"/>
- <pathelement location="${lib}/jzlib-1.0.7.jar"/>
- </path>
-
- <path id="classpath.test">
- <path refid="classpath.base"/>
- <pathelement location="${build.test}"/>
- <pathelement location="${lib}/junit-4.5.jar"/>
- <pathelement location="${lib}/javassist-3.16.1-GA.jar"/>
- </path>
- <!-- Common macro for compiling Java source -->
- <macrodef name="Compile">
- <attribute name="srcdir"/>
- <attribute name="destdir"/>
- <element name="compileoptions" implicit="true" optional="true"/>
- <sequential>
- <mkdir dir="@{destdir}"/>
- <!-- avoids needing ant clean when changing interfaces -->
- <depend srcdir="${srcdir}" destdir="${destdir}" cache="${depcache}"/>
- <javac srcdir="@{srcdir}" destdir="@{destdir}" includeAntRuntime="no"
- debug="${compile.debug}" source="${sourceversion}">
- <compilerarg value="-Xlint:unchecked" />
- <!--<compilerarg value="-Xlint:deprecation" />-->
- <compileoptions/>
- </javac>
- </sequential>
- </macrodef>
-
-
- <!-- Common macro for running junit tests in both the test and runtest targets -->
- <macrodef name="RunJunit">
- <attribute name="haltonfailure" default="yes" />
- <element name="testspecification" implicit="yes" />
- <sequential>
- <!-- timeout at 10.5 minutes, since TransactionTest is limited to 10 minutes. -->
- <junit printsummary="on" fork="yes" timeout="630000" haltonfailure="@{haltonfailure}" maxmemory="128M" failureproperty="junit.failed">
- <classpath refid="classpath.test" />
- <formatter type="plain" usefile="false"/>
- <assertions><enable/></assertions>
- <testspecification/>
- </junit>
- </sequential>
- </macrodef>
-
- <taskdef resource="net/sf/antcontrib/antlib.xml">
- <classpath>
- <pathelement location="lib/ant-contrib-1.0b3.jar"/>
- </classpath>
- </taskdef>
-
- <target name="eclipse" description="Make current directory an eclipse project">
- <echo file=".project" append="false"><?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
- <name>simpledb</name>
- <comment></comment>
- <projects>
- </projects>
- <buildSpec>
- <buildCommand>
- <name>org.eclipse.jdt.core.javabuilder</name>
- <arguments>
- </arguments>
- </buildCommand>
- </buildSpec>
- <natures>
- <nature>org.eclipse.jdt.core.javanature</nature>
- </natures>
-</projectDescription></echo>
- <echo file=".classpath" append="false"><?xml version="1.0" encoding="UTF-8"?>
-<classpath>
- <classpathentry kind="src" output="bin/src" path="src/java"/>
- <classpathentry kind="src" output="bin/test" path="test"/>
- <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
- <classpathentry kind="output" path="bin/src"/>
- </echo>
- <if> <available file="${lib}/junit-4.5.jar" /> <then>
- <echo file=".classpath" append="true">
- <classpathentry kind="lib" path="lib/junit-4.5.jar"/>
- </echo>
- </then>
- </if>
- <if> <available file="${lib}/jline-0.9.94.jar" /> <then>
- <echo file=".classpath" append="true">
- <classpathentry kind="lib" path="lib/jline-0.9.94.jar"/>
- </echo>
- </then>
- </if>
- <if> <available file="${lib}/zql.jar" /> <then>
- <echo file=".classpath" append="true">
- <classpathentry kind="lib" path="lib/zql.jar"/>
- </echo>
- </then>
- </if>
- <if> <available file="${lib}/mina-core-2.0.4.jar" /> <then>
- <echo file=".classpath" append="true">
- <classpathentry kind="lib" path="lib/mina-core-2.0.4.jar"/>
- </echo>
- </then>
- </if>
- <if> <available file="${lib}/mina-filter-compression-2.0.4.jar" /> <then>
- <echo file=".classpath" append="true">
- <classpathentry kind="lib" path="lib/mina-filter-compression-2.0.4.jar"/>
- </echo>
- </then>
- </if>
- <if> <available file="${lib}/jzlib-1.0.7.jar" /> <then>
- <echo file=".classpath" append="true">
- <classpathentry kind="lib" path="lib/jzlib-1.0.7.jar"/>
- </echo>
- </then>
- </if>
- <if> <available file="${lib}/slf4j-api-1.6.1.jar" /> <then>
- <echo file=".classpath" append="true">
- <classpathentry kind="lib" path="lib/slf4j-api-1.6.1.jar"/>
- </echo>
- </then>
- </if>
- <if> <available file="${lib}/slf4j-log4j12-1.6.1.jar" /> <then>
- <echo file=".classpath" append="true">
- <classpathentry kind="lib" path="lib/slf4j-log4j12-1.6.1.jar"/>
- </echo>
- </then>
- </if>
- <if> <available file="${lib}/log4j-1.2.17.jar" /> <then>
- <echo file=".classpath" append="true">
- <classpathentry kind="lib" path="lib/log4j-1.2.17.jar"/>
- </echo>
- </then>
- </if>
- <if> <available file="${lib}/javassist-3.16.1-GA.jar" /> <then>
- <echo file=".classpath" append="true">
- <classpathentry kind="lib" path="lib/javassist-3.16.1-GA.jar"/>
- </echo>
- </then>
- </if>
- <echo file=".classpath" append="true">
- </classpath>
- </echo>
- </target>
-
- <target name="compile" description="Compile code">
- <Compile srcdir="${src}/java" destdir="${build.src}">
- <classpath refid="classpath.base"/>
- </Compile>
- <copy todir="${build}" flatten="true">
- <fileset dir="${src}">
- <include name="bin/*.sh"/>
- </fileset>
- </copy>
- </target>
-
- <target name="javadocs" description="Build javadoc documentation">
- <javadoc destdir="${doc}" access="private" failonerror="true" source="${sourceversion}">
- <classpath refid="classpath.base" />
- <fileset dir="src/java" defaultexcludes="yes">
- <include name="simpledb/**/*.java"/>
- </fileset>
- </javadoc>
- </target>
-
- <target name="dist" depends="compile" description="Build jar">
- <mkdir dir="${dist}"/>
- <jar jarfile="${jarfile}" basedir="${build.src}">
- <manifest>
- <attribute name="Main-Class" value="simpledb.SimpleDb"/>
- <attribute name="Class-Path" value="../lib/zql.jar ../lib/jline-0.9.94.jar ../lib/jzlib-1.0.7.jar ../lib/mina-core-2.0.4.jar ../lib/mina-filter-compression-2.0.4.jar ../lib/slf4j-api-1.6.1.jar ../lib/slf4j-log4j12-1.6.1.jar ../lib/log4j-1.2.17.jar "/>
- </manifest>
- <!-- Merge library jars into final jar file -->
- <!--<zipgroupfileset refid="lib.jars"/>-->
- </jar>
- </target>
-
- <target name="clean" description="Remove build and dist directories">
- <delete dir="${build}"/>
- <delete dir="${dist}"/>
- <delete dir="${doc}"/>
- <delete dir="${test.reports}"/>
- </target>
-
- <target name="testcompile" depends="compile" description="Compile all unit and system tests">
- <Compile srcdir="${testd}" destdir="${build.test}">
- <classpath refid="classpath.test"/>
- </Compile>
- </target>
-
- <target name="test" depends="testcompile" description="Run all unit tests">
- <RunJunit>
- <batchtest>
- <fileset dir="${build.test}">
- <include name="**/*Test.class"/>
- <exclude name="**/*$*.class"/>
- <exclude name="simpledb/systemtest/*.class"/>
- </fileset>
- </batchtest>
- </RunJunit>
- </target>
-
- <target name="systemtest" depends="testcompile" description="Run all system tests">
- <RunJunit>
- <batchtest>
- <fileset dir="${build.test}">
- <include name="simpledb/systemtest/*Test.class"/>
- </fileset>
- </batchtest>
- </RunJunit>
- </target>
-
- <target name="runtest" depends="testcompile"
- description="Runs the test you specify on the command line with -Dtest=">
- <!-- Check for -Dtest command line argument -->
- <fail unless="test" message="You must run this target with -Dtest=TestName"/>
-
- <!-- Check if the class exists -->
- <available property="test.exists" classname="simpledb.${test}">
- <classpath refid="classpath.test" />
- </available>
- <fail unless="test.exists" message="Test ${test} could not be found"/>
-
- <RunJunit>
- <test name="simpledb.${test}"/>
- </RunJunit>
- </target>
-
- <target name="runsystest" depends="testcompile"
- description="Runs the system test you specify on the command line with -Dtest=">
- <!-- Check for -Dtest command line argument -->
- <fail unless="test" message="You must run this target with -Dtest=TestName"/>
-
- <!-- Check if the class exists -->
- <available property="test.exists" classname="simpledb.systemtest.${test}">
- <classpath refid="classpath.test" />
- </available>
- <fail unless="test.exists" message="Test ${test} could not be found"/>
-
- <RunJunit>
- <test name="simpledb.systemtest.${test}"/>
- </RunJunit>
- </target>
-
-
- <!-- The following target is used for automated grading. -->
- <target name="test-report" depends="testcompile"
- description="Generates HTML test reports in ${test.reports}">
- <mkdir dir="${test.reports}"/>
-
- <!-- do not halt on failure so we always produce HTML reports. -->
- <RunJunit haltonfailure="no">
- <formatter type="xml"/>
- <formatter type="plain" usefile="true"/>
- <batchtest todir="${test.reports}" >
- <fileset dir="${build.test}">
- <include name="**/*Test.class"/>
- <exclude name="**/*$*.class"/>
- </fileset>
- </batchtest>
- </RunJunit>
-
- <junitreport todir="${test.reports}">
- <fileset dir="${test.reports}">
- <include name="TEST-*.xml" />
- </fileset>
- <report todir="${test.reports}" />
- </junitreport>
-
- <!-- Fail here if the junit tests failed. -->
- <fail if="junit.failed" message="Some JUnit tests failed"/>
- </target>
-
- <target name="handin" depends="clean"
- description="Create a tarball of your code to hand in">
- <tar destfile="lab-handin.tar.bz2" compression="bzip2"
- basedir="." />
- <echo message="Tarball created! Please submit 'lab-handin.tar.bz2' per the instructions in the lab document." />
- <subant target="dist">
- <fileset dir="." includes="build.xml"/>
- </subant>
- </target>
-
- <target name="test-and-handin" depends="test,systemtest,handin"
- description="Run all the tests and system tests; if they succeed, create a tarball of the source code to submit" />
-
-</project>
diff --git a/hw/hw3/starter-code/lib/LICENSE.javassist.html b/hw/hw3/starter-code/lib/LICENSE.javassist.html
deleted file mode 100644
index 7d842b40bcb66a19c745720e0b6024dea6355de1..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/lib/LICENSE.javassist.html
+++ /dev/null
@@ -1,373 +0,0 @@
-<HTML>
-<HEAD>
-<TITLE>Javassist License</TITLE>
-<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
-<META content="MSHTML 5.50.4916.2300" name=GENERATOR></HEAD>
-
-<BODY text=#000000 vLink=#551a8b aLink=#ff0000 link=#0000ee bgColor=#ffffff>
-<CENTER><B><FONT size=+2>MOZILLA PUBLIC LICENSE</FONT></B> <BR><B>Version
-1.1</B>
-<P>
-<HR width="20%">
-</CENTER>
-<P><B>1. Definitions.</B>
-<UL><B>1.0.1. "Commercial Use" </B>means distribution or otherwise making the
- Covered Code available to a third party.
- <P><B>1.1. ''Contributor''</B> means each entity that creates or contributes
- to the creation of Modifications.
- <P><B>1.2. ''Contributor Version''</B> means the combination of the Original
- Code, prior Modifications used by a Contributor, and the Modifications made by
- that particular Contributor.
- <P><B>1.3. ''Covered Code''</B> means the Original Code or Modifications or
- the combination of the Original Code and Modifications, in each case including
- portions thereof<B>.</B>
- <P><B>1.4. ''Electronic Distribution Mechanism''</B> means a mechanism
- generally accepted in the software development community for the electronic
- transfer of data.
- <P><B>1.5. ''Executable''</B> means Covered Code in any form other than Source
- Code.
- <P><B>1.6. ''Initial Developer''</B> means the individual or entity identified
- as the Initial Developer in the Source Code notice required by <B>Exhibit
- A</B>.
- <P><B>1.7. ''Larger Work''</B> means a work which combines Covered Code or
- portions thereof with code not governed by the terms of this License.
- <P><B>1.8. ''License''</B> means this document.
- <P><B>1.8.1. "Licensable"</B> means having the right to grant, to the maximum
- extent possible, whether at the time of the initial grant or subsequently
- acquired, any and all of the rights conveyed herein.
- <P><B>1.9. ''Modifications''</B> means any addition to or deletion from the
- substance or structure of either the Original Code or any previous
- Modifications. When Covered Code is released as a series of files, a
- Modification is:
- <UL><B>A.</B> Any addition to or deletion from the contents of a file
- containing Original Code or previous Modifications.
- <P><B>B.</B> Any new file that contains any part of the Original Code or
- previous Modifications. <BR> </P></UL><B>1.10. ''Original Code''</B>
- means Source Code of computer software code which is described in the Source
- Code notice required by <B>Exhibit A</B> as Original Code, and which, at the
- time of its release under this License is not already Covered Code governed by
- this License.
- <P><B>1.10.1. "Patent Claims"</B> means any patent claim(s), now owned or
- hereafter acquired, including without limitation, method, process, and
- apparatus claims, in any patent Licensable by grantor.
- <P><B>1.11. ''Source Code''</B> means the preferred form of the Covered Code
- for making modifications to it, including all modules it contains, plus any
- associated interface definition files, scripts used to control compilation and
- installation of an Executable, or source code differential comparisons against
- either the Original Code or another well known, available Covered Code of the
- Contributor's choice. The Source Code can be in a compressed or archival form,
- provided the appropriate decompression or de-archiving software is widely
- available for no charge.
- <P><B>1.12. "You'' (or "Your") </B> means an individual or a legal entity
- exercising rights under, and complying with all of the terms of, this License
- or a future version of this License issued under Section 6.1. For legal
- entities, "You'' includes any entity which controls, is controlled by, or is
- under common control with You. For purposes of this definition, "control''
- means (a) the power, direct or indirect, to cause the direction or management
- of such entity, whether by contract or otherwise, or (b) ownership of more
- than fifty percent (50%) of the outstanding shares or beneficial ownership of
- such entity.</P></UL><B>2. Source Code License.</B>
-<UL><B>2.1. The Initial Developer Grant.</B> <BR>The Initial Developer hereby
- grants You a world-wide, royalty-free, non-exclusive license, subject to third
- party intellectual property claims:
- <UL><B>(a)</B> <B> </B>under intellectual property rights (other than
- patent or trademark) Licensable by Initial Developer to use, reproduce,
- modify, display, perform, sublicense and distribute the Original Code (or
- portions thereof) with or without Modifications, and/or as part of a Larger
- Work; and
- <P><B>(b)</B> under Patents Claims infringed by the making, using or selling
- of Original Code, to make, have made, use, practice, sell, and offer for
- sale, and/or otherwise dispose of the Original Code (or portions thereof).
- <UL>
- <UL></UL></UL><B>(c) </B>the licenses granted in this Section 2.1(a) and (b)
- are effective on the date Initial Developer first distributes Original Code
- under the terms of this License.
- <P><B>(d) </B>Notwithstanding Section 2.1(b) above, no patent license is
- granted: 1) for code that You delete from the Original Code; 2) separate
- from the Original Code; or 3) for infringements caused by: i) the
- modification of the Original Code or ii) the combination of the Original
- Code with other software or devices. <BR> </P></UL><B>2.2. Contributor
- Grant.</B> <BR>Subject to third party intellectual property claims, each
- Contributor hereby grants You a world-wide, royalty-free, non-exclusive
- license
- <UL> <BR><B>(a)</B> <B> </B>under intellectual property rights (other
- than patent or trademark) Licensable by Contributor, to use, reproduce,
- modify, display, perform, sublicense and distribute the Modifications
- created by such Contributor (or portions thereof) either on an unmodified
- basis, with other Modifications, as Covered Code and/or as part of a Larger
- Work; and
- <P><B>(b)</B> under Patent Claims infringed by the making, using, or selling
- of Modifications made by that Contributor either alone and/or in<FONT
- color=#000000> combination with its Contributor Version (or portions of such
- combination), to make, use, sell, offer for sale, have made, and/or
- otherwise dispose of: 1) Modifications made by that Contributor (or portions
- thereof); and 2) the combination of Modifications made by that
- Contributor with its Contributor Version (or portions of such
- combination).</FONT>
- <P><B>(c) </B>the licenses granted in Sections 2.2(a) and 2.2(b) are
- effective on the date Contributor first makes Commercial Use of the Covered
- Code.
- <P><B>(d) </B> Notwithstanding Section 2.2(b) above, no
- patent license is granted: 1) for any code that Contributor has deleted from
- the Contributor Version; 2) separate from the Contributor
- Version; 3) for infringements caused by: i) third party
- modifications of Contributor Version or ii) the combination of
- Modifications made by that Contributor with other software (except as
- part of the Contributor Version) or other devices; or 4) under Patent Claims
- infringed by Covered Code in the absence of Modifications made by that
- Contributor.</P></UL></UL>
-<P><BR><B>3. Distribution Obligations.</B>
-<UL><B>3.1. Application of License.</B> <BR>The Modifications which You create
- or to which You contribute are governed by the terms of this License,
- including without limitation Section <B>2.2</B>. The Source Code version of
- Covered Code may be distributed only under the terms of this License or a
- future version of this License released under Section <B>6.1</B>, and You must
- include a copy of this License with every copy of the Source Code You
- distribute. You may not offer or impose any terms on any Source Code version
- that alters or restricts the applicable version of this License or the
- recipients' rights hereunder. However, You may include an additional document
- offering the additional rights described in Section <B>3.5</B>.
- <P><B>3.2. Availability of Source Code.</B> <BR>Any Modification which You
- create or to which You contribute must be made available in Source Code form
- under the terms of this License either on the same media as an Executable
- version or via an accepted Electronic Distribution Mechanism to anyone to whom
- you made an Executable version available; and if made available via Electronic
- Distribution Mechanism, must remain available for at least twelve (12) months
- after the date it initially became available, or at least six (6) months after
- a subsequent version of that particular Modification has been made available
- to such recipients. You are responsible for ensuring that the Source Code
- version remains available even if the Electronic Distribution Mechanism is
- maintained by a third party.
- <P><B>3.3. Description of Modifications.</B> <BR>You must cause all Covered
- Code to which You contribute to contain a file documenting the changes You
- made to create that Covered Code and the date of any change. You must include
- a prominent statement that the Modification is derived, directly or
- indirectly, from Original Code provided by the Initial Developer and including
- the name of the Initial Developer in (a) the Source Code, and (b) in any
- notice in an Executable version or related documentation in which You describe
- the origin or ownership of the Covered Code.
- <P><B>3.4. Intellectual Property Matters</B>
- <UL><B>(a) Third Party Claims</B>. <BR>If Contributor has knowledge that a
- license under a third party's intellectual property rights is required to
- exercise the rights granted by such Contributor under Sections 2.1 or 2.2,
- Contributor must include a text file with the Source Code distribution
- titled "LEGAL'' which describes the claim and the party making the claim in
- sufficient detail that a recipient will know whom to contact. If Contributor
- obtains such knowledge after the Modification is made available as described
- in Section 3.2, Contributor shall promptly modify the LEGAL file in all
- copies Contributor makes available thereafter and shall take other steps
- (such as notifying appropriate mailing lists or newsgroups) reasonably
- calculated to inform those who received the Covered Code that new knowledge
- has been obtained.
- <P><B>(b) Contributor APIs</B>. <BR>If Contributor's Modifications include
- an application programming interface and Contributor has knowledge of patent
- licenses which are reasonably necessary to implement that API, Contributor
- must also include this information in the LEGAL file.
- <BR> </P></UL>
- <B>(c) Representations.</B>
- <UL>Contributor represents that, except as disclosed pursuant to Section
- 3.4(a) above, Contributor believes that Contributor's Modifications are
- Contributor's original creation(s) and/or Contributor has sufficient rights
- to grant the rights conveyed by this License.</UL>
- <P><BR><B>3.5. Required Notices.</B> <BR>You must duplicate the notice in
- <B>Exhibit A</B> in each file of the Source Code. If it is not possible
- to put such notice in a particular Source Code file due to its structure, then
- You must include such notice in a location (such as a relevant directory)
- where a user would be likely to look for such a notice. If You created
- one or more Modification(s) You may add your name as a Contributor to the
- notice described in <B>Exhibit A</B>. You must also duplicate this
- License in any documentation for the Source Code where You describe
- recipients' rights or ownership rights relating to Covered Code. You may
- choose to offer, and to charge a fee for, warranty, support, indemnity or
- liability obligations to one or more recipients of Covered Code. However, You
- may do so only on Your own behalf, and not on behalf of the Initial Developer
- or any Contributor. You must make it absolutely clear than any such warranty,
- support, indemnity or liability obligation is offered by You alone, and You
- hereby agree to indemnify the Initial Developer and every Contributor for any
- liability incurred by the Initial Developer or such Contributor as a result of
- warranty, support, indemnity or liability terms You offer.
- <P><B>3.6. Distribution of Executable Versions.</B> <BR>You may distribute
- Covered Code in Executable form only if the requirements of Section
- <B>3.1-3.5</B> have been met for that Covered Code, and if You include a
- notice stating that the Source Code version of the Covered Code is available
- under the terms of this License, including a description of how and where You
- have fulfilled the obligations of Section <B>3.2</B>. The notice must be
- conspicuously included in any notice in an Executable version, related
- documentation or collateral in which You describe recipients' rights relating
- to the Covered Code. You may distribute the Executable version of Covered Code
- or ownership rights under a license of Your choice, which may contain terms
- different from this License, provided that You are in compliance with the
- terms of this License and that the license for the Executable version does not
- attempt to limit or alter the recipient's rights in the Source Code version
- from the rights set forth in this License. If You distribute the Executable
- version under a different license You must make it absolutely clear that any
- terms which differ from this License are offered by You alone, not by the
- Initial Developer or any Contributor. You hereby agree to indemnify the
- Initial Developer and every Contributor for any liability incurred by the
- Initial Developer or such Contributor as a result of any such terms You offer.
-
- <P><B>3.7. Larger Works.</B> <BR>You may create a Larger Work by combining
- Covered Code with other code not governed by the terms of this License and
- distribute the Larger Work as a single product. In such a case, You must make
- sure the requirements of this License are fulfilled for the Covered
-Code.</P></UL><B>4. Inability to Comply Due to Statute or Regulation.</B>
-<UL>If it is impossible for You to comply with any of the terms of this
- License with respect to some or all of the Covered Code due to statute,
- judicial order, or regulation then You must: (a) comply with the terms of this
- License to the maximum extent possible; and (b) describe the limitations and
- the code they affect. Such description must be included in the LEGAL file
- described in Section <B>3.4</B> and must be included with all distributions of
- the Source Code. Except to the extent prohibited by statute or regulation,
- such description must be sufficiently detailed for a recipient of ordinary
- skill to be able to understand it.</UL><B>5. Application of this License.</B>
-<UL>This License applies to code to which the Initial Developer has attached
- the notice in <B>Exhibit A</B> and to related Covered Code.</UL><B>6. Versions
-of the License.</B>
-<UL><B>6.1. New Versions</B>. <BR>Netscape Communications Corporation
- (''Netscape'') may publish revised and/or new versions of the License from
- time to time. Each version will be given a distinguishing version number.
- <P><B>6.2. Effect of New Versions</B>. <BR>Once Covered Code has been
- published under a particular version of the License, You may always continue
- to use it under the terms of that version. You may also choose to use such
- Covered Code under the terms of any subsequent version of the License
- published by Netscape. No one other than Netscape has the right to modify the
- terms applicable to Covered Code created under this License.
- <P><B>6.3. Derivative Works</B>. <BR>If You create or use a modified version
- of this License (which you may only do in order to apply it to code which is
- not already Covered Code governed by this License), You must (a) rename Your
- license so that the phrases ''Mozilla'', ''MOZILLAPL'', ''MOZPL'',
- ''Netscape'', "MPL", ''NPL'' or any confusingly similar phrase do not appear
- in your license (except to note that your license differs from this License)
- and (b) otherwise make it clear that Your version of the license contains
- terms which differ from the Mozilla Public License and Netscape Public
- License. (Filling in the name of the Initial Developer, Original Code or
- Contributor in the notice described in <B>Exhibit A</B> shall not of
- themselves be deemed to be modifications of this License.)</P></UL><B>7.
-DISCLAIMER OF WARRANTY.</B>
-<UL>COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS'' BASIS, WITHOUT
- WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT
- LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE,
- FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE
- QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED
- CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY
- OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR
- CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
- LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS
- DISCLAIMER.</UL><B>8. TERMINATION.</B>
-<UL><B>8.1. </B>This License and the rights granted hereunder will
- terminate automatically if You fail to comply with terms herein and fail to
- cure such breach within 30 days of becoming aware of the breach. All
- sublicenses to the Covered Code which are properly granted shall survive any
- termination of this License. Provisions which, by their nature, must remain in
- effect beyond the termination of this License shall survive.
- <P><B>8.2. </B>If You initiate litigation by asserting a patent
- infringement claim (excluding declatory judgment actions) against Initial
- Developer or a Contributor (the Initial Developer or Contributor against whom
- You file such action is referred to as "Participant") alleging that:
- <P><B>(a) </B>such Participant's Contributor Version directly or
- indirectly infringes any patent, then any and all rights granted by such
- Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon
- 60 days notice from Participant terminate prospectively, unless if within 60
- days after receipt of notice You either: (i) agree in writing to pay
- Participant a mutually agreeable reasonable royalty for Your past and future
- use of Modifications made by such Participant, or (ii) withdraw Your
- litigation claim with respect to the Contributor Version against such
- Participant. If within 60 days of notice, a reasonable royalty and
- payment arrangement are not mutually agreed upon in writing by the parties or
- the litigation claim is not withdrawn, the rights granted by Participant to
- You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of
- the 60 day notice period specified above.
- <P><B>(b)</B> any software, hardware, or device, other than such
- Participant's Contributor Version, directly or indirectly infringes any
- patent, then any rights granted to You by such Participant under Sections
- 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used,
- sold, distributed, or had made, Modifications made by that Participant.
- <P><B>8.3. </B>If You assert a patent infringement claim against
- Participant alleging that such Participant's Contributor Version directly or
- indirectly infringes any patent where such claim is resolved (such as by
- license or settlement) prior to the initiation of patent infringement
- litigation, then the reasonable value of the licenses granted by such
- Participant under Sections 2.1 or 2.2 shall be taken into account in
- determining the amount or value of any payment or license.
- <P><B>8.4.</B> In the event of termination under Sections 8.1 or 8.2
- above, all end user license agreements (excluding distributors and
- resellers) which have been validly granted by You or any distributor hereunder
- prior to termination shall survive termination.</P></UL><B>9. LIMITATION OF
-LIABILITY.</B>
-<UL>UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING
- NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY
- OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY
- OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL,
- INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT
- LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR
- MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH
- PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS
- LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL
- INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW
- PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR
- LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND
- LIMITATION MAY NOT APPLY TO YOU.</UL><B>10. U.S. GOVERNMENT END USERS.</B>
-<UL>The Covered Code is a ''commercial item,'' as that term is defined in 48
- C.F.R. 2.101 (Oct. 1995), consisting of ''commercial computer software'' and
- ''commercial computer software documentation,'' as such terms are used in 48
- C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R.
- 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users
- acquire Covered Code with only those rights set forth herein.</UL><B>11.
-MISCELLANEOUS.</B>
-<UL>This License represents the complete agreement concerning subject matter
- hereof. If any provision of this License is held to be unenforceable, such
- provision shall be reformed only to the extent necessary to make it
- enforceable. This License shall be governed by California law provisions
- (except to the extent applicable law, if any, provides otherwise), excluding
- its conflict-of-law provisions. With respect to disputes in which at least one
- party is a citizen of, or an entity chartered or registered to do business in
- the United States of America, any litigation relating to this License shall be
- subject to the jurisdiction of the Federal Courts of the Northern District of
- California, with venue lying in Santa Clara County, California, with the
- losing party responsible for costs, including without limitation, court costs
- and reasonable attorneys' fees and expenses. The application of the United
- Nations Convention on Contracts for the International Sale of Goods is
- expressly excluded. Any law or regulation which provides that the language of
- a contract shall be construed against the drafter shall not apply to this
- License.</UL><B>12. RESPONSIBILITY FOR CLAIMS.</B>
-<UL>As between Initial Developer and the Contributors, each party is
- responsible for claims and damages arising, directly or indirectly, out of its
- utilization of rights under this License and You agree to work with Initial
- Developer and Contributors to distribute such responsibility on an equitable
- basis. Nothing herein is intended or shall be deemed to constitute any
- admission of liability.</UL><B>13. MULTIPLE-LICENSED CODE.</B>
-<UL>Initial Developer may designate portions of the Covered Code as
- "Multiple-Licensed". "Multiple-Licensed" means that the Initial
- Developer permits you to utilize portions of the Covered Code under Your
- choice of the MPL or the alternative licenses, if any, specified by the
- Initial Developer in the file described in Exhibit A.</UL>
-<P><BR><B>EXHIBIT A -Mozilla Public License.</B>
-<UL>The contents of this file are subject to the Mozilla Public License
- Version 1.1 (the "License"); you may not use this file except in compliance
- with the License. You may obtain a copy of the License at
- <BR>http://www.mozilla.org/MPL/
- <P>Software distributed under the License is distributed on an "AS IS" basis,
- WITHOUT WARRANTY OF <BR>ANY KIND, either express or implied. See the License
- for the specific language governing rights and <BR>limitations under the
- License.
- <P>The Original Code is Javassist.
- <P>The Initial Developer of the Original Code is Shigeru Chiba.
- Portions created by the Initial Developer are<BR>
- Copyright (C) 1999- Shigeru Chiba. All Rights Reserved.
- <P>Contributor(s): __Bill Burke, Jason T. Greene______________.
-
-<p>Alternatively, the contents of this software may be used under the
-terms of the GNU Lesser General Public License Version 2.1 or later
-(the "LGPL"), or the Apache License Version 2.0 (the "AL"),
-in which case the provisions of the LGPL or the AL are applicable
-instead of those above. If you wish to allow use of your version of
-this software only under the terms of either the LGPL or the AL, and not to allow others to
-use your version of this software under the terms of the MPL, indicate
-your decision by deleting the provisions above and replace them with
-the notice and other provisions required by the LGPL or the AL. If you do not
-delete the provisions above, a recipient may use your version of this
-software under the terms of any one of the MPL, the LGPL or the AL.
-
- <P></P></UL>
-</BODY>
-</HTML>
diff --git a/hw/hw3/starter-code/lib/LICENSE.jzlib.txt b/hw/hw3/starter-code/lib/LICENSE.jzlib.txt
deleted file mode 100644
index cdce5007d0ec51a8f19ac48e188d0f0d7474c8ff..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/lib/LICENSE.jzlib.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-JZlib 0.0.* were released under the GNU LGPL license. Later, we have switched
-over to a BSD-style license.
-
-------------------------------------------------------------------------------
-Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
- this list of conditions and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in
- the documentation and/or other materials provided with the distribution.
-
- 3. The names of the authors may not be used to endorse or promote products
- derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
-INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
-INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/hw/hw3/starter-code/lib/LICENSE.mina.txt b/hw/hw3/starter-code/lib/LICENSE.mina.txt
deleted file mode 100644
index 66a27ec5ff940d3a9652d2948746ebac4c9d0188..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/lib/LICENSE.mina.txt
+++ /dev/null
@@ -1,177 +0,0 @@
- Apache License
- Version 2.0, January 2004
- http://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
-
diff --git a/hw/hw3/starter-code/lib/LICENSE.slf4j.txt b/hw/hw3/starter-code/lib/LICENSE.slf4j.txt
deleted file mode 100644
index e663b1d7f0ebbfcd7afba663d7e333e41978f999..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/lib/LICENSE.slf4j.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-Copyright (c) 2004-2007 QOS.ch
-All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, and/or sell copies of the Software, and to permit persons
-to whom the Software is furnished to do so, provided that the above
-copyright notice(s) and this permission notice appear in all copies of
-the Software and that both the above copyright notice(s) and this
-permission notice appear in supporting documentation.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY
-SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER
-RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
-CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
-CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-Except as contained in this notice, the name of a copyright holder
-shall not be used in advertising or otherwise to promote the sale, use
-or other dealings in this Software without prior written authorization
-of the copyright holder.
-
diff --git a/hw/hw3/starter-code/lib/README b/hw/hw3/starter-code/lib/README
deleted file mode 100644
index 7a6efb645c2fb156beca728f8b8d1a9e9b9e2239..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/lib/README
+++ /dev/null
@@ -1,60 +0,0 @@
-junit-4.5.jar
-* http://junit.sourceforge.net/
-* CPL (free for all use)
-
-zql.jar
-* http://www.gibello.com/code/zql/
-* Free for non-commercial use
-
-JLine
-* http://jline.sourceforge.net/
-* BSD (free for all use)
-<<<<<<< .working
-
-mina-core-2.0.4.jar
-mina-filter-compression-2.0.4.jar
-* http://mina.apache.org/
-* Apache License v2.0 (free for all use)
-
-slf4j-api-1.6.1.jar
-* http://www.slf4j.org/license.html
-* MIT license (free for all use)
-
-jzlib-1.0.7.jar
-* http://www.jcraft.com/jzlib/
-* BSD (free for all use)
-
-javassist-3.16.1-GA.jar
-* http://www.javassist.org/
-* MPL v1.1, LGPL and Apache License
-
-=======
-
-mina-core-2.0.4.jar
-mina-filter-compression-2.0.4.jar
-* http://mina.apache.org/
-* Apache License v2.0 (free for all use)
-
-slf4j-api-1.6.1.jar
-slf4j-log4j12-1.6.1.jar
-* http://www.slf4j.org/license.html
-* MIT license (free for all use)
-
-jzlib-1.0.7.jar
-* http://www.jcraft.com/jzlib/
-* BSD (free for all use)
-
-javassist-3.16.1-GA.jar
-* http://www.javassist.org/
-* MPL v1.1, LGPL and Apache License
-
-ant-contrib-1.0b3.jar
-* http://ant-contrib.sourceforge.net/
-* Apache Software License
-
-log4j-1.2.17.jar
-* logging.apache.org/log4j/1.2/
-* Apache Software license 2.0
-
-
->>>>>>> .merge-right.r755
diff --git a/hw/hw3/starter-code/lib/ant-contrib-1.0b3.jar b/hw/hw3/starter-code/lib/ant-contrib-1.0b3.jar
deleted file mode 100644
index 062537661a514c2ce97d18948f4f25f7226cc1a0..0000000000000000000000000000000000000000
Binary files a/hw/hw3/starter-code/lib/ant-contrib-1.0b3.jar and /dev/null differ
diff --git a/hw/hw3/starter-code/lib/javassist-3.16.1-GA.jar b/hw/hw3/starter-code/lib/javassist-3.16.1-GA.jar
deleted file mode 100644
index e8abb1971439e2508c6f370cdd025bc9067202db..0000000000000000000000000000000000000000
Binary files a/hw/hw3/starter-code/lib/javassist-3.16.1-GA.jar and /dev/null differ
diff --git a/hw/hw3/starter-code/lib/jline-0.9.94.jar b/hw/hw3/starter-code/lib/jline-0.9.94.jar
deleted file mode 100644
index dafca7c46e96ce462ef8e2457a4bbd6c21dcd0b7..0000000000000000000000000000000000000000
Binary files a/hw/hw3/starter-code/lib/jline-0.9.94.jar and /dev/null differ
diff --git a/hw/hw3/starter-code/lib/junit-4.5.jar b/hw/hw3/starter-code/lib/junit-4.5.jar
deleted file mode 100644
index 733921623d4a71ae2ae1432228e6eba5e508ae4c..0000000000000000000000000000000000000000
Binary files a/hw/hw3/starter-code/lib/junit-4.5.jar and /dev/null differ
diff --git a/hw/hw3/starter-code/lib/jzlib-1.0.7.jar b/hw/hw3/starter-code/lib/jzlib-1.0.7.jar
deleted file mode 100644
index 112d4fd43d14c9880b204235587158264cdf723c..0000000000000000000000000000000000000000
Binary files a/hw/hw3/starter-code/lib/jzlib-1.0.7.jar and /dev/null differ
diff --git a/hw/hw3/starter-code/lib/log4j-1.2.17.jar b/hw/hw3/starter-code/lib/log4j-1.2.17.jar
deleted file mode 100644
index 068867ebfd231db09a7775794eea8127420380ed..0000000000000000000000000000000000000000
Binary files a/hw/hw3/starter-code/lib/log4j-1.2.17.jar and /dev/null differ
diff --git a/hw/hw3/starter-code/lib/mina-core-2.0.4.jar b/hw/hw3/starter-code/lib/mina-core-2.0.4.jar
deleted file mode 100644
index 985fb797a44f7eccdf27b4ec7da9e667f0683f91..0000000000000000000000000000000000000000
Binary files a/hw/hw3/starter-code/lib/mina-core-2.0.4.jar and /dev/null differ
diff --git a/hw/hw3/starter-code/lib/mina-filter-compression-2.0.4.jar b/hw/hw3/starter-code/lib/mina-filter-compression-2.0.4.jar
deleted file mode 100644
index 3db65710c167f5ac3c482132aa43e7d1c072e4e1..0000000000000000000000000000000000000000
Binary files a/hw/hw3/starter-code/lib/mina-filter-compression-2.0.4.jar and /dev/null differ
diff --git a/hw/hw3/starter-code/lib/slf4j-api-1.6.1.jar b/hw/hw3/starter-code/lib/slf4j-api-1.6.1.jar
deleted file mode 100644
index f1f4fdd214940c76cefaad2419e538e4c13cef6b..0000000000000000000000000000000000000000
Binary files a/hw/hw3/starter-code/lib/slf4j-api-1.6.1.jar and /dev/null differ
diff --git a/hw/hw3/starter-code/lib/slf4j-log4j12-1.6.1.jar b/hw/hw3/starter-code/lib/slf4j-log4j12-1.6.1.jar
deleted file mode 100644
index 641159959c21651235677a4912bb58bc47cfef41..0000000000000000000000000000000000000000
Binary files a/hw/hw3/starter-code/lib/slf4j-log4j12-1.6.1.jar and /dev/null differ
diff --git a/hw/hw3/starter-code/lib/zql.jar b/hw/hw3/starter-code/lib/zql.jar
deleted file mode 100644
index 7e7b256f41e7a77947be636dfd089139374ccd0f..0000000000000000000000000000000000000000
Binary files a/hw/hw3/starter-code/lib/zql.jar and /dev/null differ
diff --git a/hw/hw3/starter-code/src/java/simpledb/Aggregate.java b/hw/hw3/starter-code/src/java/simpledb/Aggregate.java
deleted file mode 100644
index 11f169427cb12ea5adb096f29cbdcabe4dc6e817..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Aggregate.java
+++ /dev/null
@@ -1,137 +0,0 @@
-package simpledb;
-
-import java.util.*;
-
-/**
- * The Aggregation operator that computes an aggregate (e.g., sum, avg, max,
- * min). Note that we only support aggregates over a single column, grouped by a
- * single column.
- */
-public class Aggregate extends Operator {
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Constructor.
- *
- * Implementation hint: depending on the type of afield, you will want to
- * construct an {@link IntAggregator} or {@link StringAggregator} to help
- * you with your implementation of readNext().
- *
- *
- * @param child
- * The DbIterator that is feeding us tuples.
- * @param afield
- * The column over which we are computing an aggregate.
- * @param gfield
- * The column over which we are grouping the result, or -1 if
- * there is no grouping
- * @param aop
- * The aggregation operator to use
- */
- public Aggregate(DbIterator child, int afield, int gfield, Aggregator.Op aop) {
- // some code goes here
- }
-
- /**
- * @return If this aggregate is accompanied by a groupby, return the groupby
- * field index in the <b>INPUT</b> tuples. If not, return
- * {@link simpledb.Aggregator#NO_GROUPING}
- * */
- public int groupField() {
- // some code goes here
- return -1;
- }
-
- /**
- * @return If this aggregate is accompanied by a group by, return the name
- * of the groupby field in the <b>OUTPUT</b> tuples If not, return
- * null;
- * */
- public String groupFieldName() {
- // some code goes here
- return null;
- }
-
- /**
- * @return the aggregate field
- * */
- public int aggregateField() {
- // some code goes here
- return -1;
- }
-
- /**
- * @return return the name of the aggregate field in the <b>OUTPUT</b>
- * tuples
- * */
- public String aggregateFieldName() {
- // some code goes here
- return null;
- }
-
- /**
- * @return return the aggregate operator
- * */
- public Aggregator.Op aggregateOp() {
- // some code goes here
- return null;
- }
-
- public static String nameOfAggregatorOp(Aggregator.Op aop) {
- return aop.toString();
- }
-
- public void open() throws NoSuchElementException, DbException,
- TransactionAbortedException {
- // some code goes here
- }
-
- /**
- * Returns the next tuple. If there is a group by field, then the first
- * field is the field by which we are grouping, and the second field is the
- * result of computing the aggregate, If there is no group by field, then
- * the result tuple should contain one field representing the result of the
- * aggregate. Should return null if there are no more tuples.
- */
- protected Tuple fetchNext() throws TransactionAbortedException, DbException {
- // some code goes here
- return null;
- }
-
- public void rewind() throws DbException, TransactionAbortedException {
- // some code goes here
- }
-
- /**
- * Returns the TupleDesc of this Aggregate. If there is no group by field,
- * this will have one field - the aggregate column. If there is a group by
- * field, the first field will be the group by field, and the second will be
- * the aggregate value column.
- *
- * The name of an aggregate column should be informative. For example:
- * "aggName(aop) (child_td.getFieldName(afield))" where aop and afield are
- * given in the constructor, and child_td is the TupleDesc of the child
- * iterator.
- */
- public TupleDesc getTupleDesc() {
- // some code goes here
- return null;
- }
-
- public void close() {
- // some code goes here
- }
-
- @Override
- public DbIterator[] getChildren() {
- // some code goes here
- return null;
- }
-
- @Override
- public void setChildren(DbIterator[] children) {
- // some code goes here
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Aggregator.java b/hw/hw3/starter-code/src/java/simpledb/Aggregator.java
deleted file mode 100644
index ee53ada6f5b76956643bdefff70e6348d2ebd3bd..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Aggregator.java
+++ /dev/null
@@ -1,85 +0,0 @@
-package simpledb;
-
-import java.io.Serializable;
-
-/**
- * The common interface for any class that can compute an aggregate over a
- * list of Tuples.
- */
-public interface Aggregator extends Serializable {
- static final int NO_GROUPING = -1;
-
- /**
- * SUM_COUNT and SC_AVG will
- * only be used in lab6, you are not required
- * to implement them until then.
- * */
- public enum Op implements Serializable {
- MIN, MAX, SUM, AVG, COUNT,
- /**
- * SUM_COUNT: compute sum and count simultaneously, will be
- * needed to compute distributed avg in lab6.
- * */
- SUM_COUNT,
- /**
- * SC_AVG: compute the avg of a set of SUM_COUNT tuples,
- * will be used to compute distributed avg in lab6.
- * */
- SC_AVG;
-
- /**
- * Interface to access operations by a string containing an integer
- * index for command-line convenience.
- *
- * @param s a string containing a valid integer Op index
- */
- public static Op getOp(String s) {
- return getOp(Integer.parseInt(s));
- }
-
- /**
- * Interface to access operations by integer value for command-line
- * convenience.
- *
- * @param i a valid integer Op index
- */
- public static Op getOp(int i) {
- return values()[i];
- }
-
- public String toString()
- {
- if (this==MIN)
- return "min";
- if (this==MAX)
- return "max";
- if (this==SUM)
- return "sum";
- if (this==SUM_COUNT)
- return "sum_count";
- if (this==AVG)
- return "avg";
- if (this==COUNT)
- return "count";
- if (this==SC_AVG)
- return "sc_avg";
- throw new IllegalStateException("impossible to reach here");
- }
- }
-
- /**
- * Merge a new tuple into the aggregate for a distinct group value;
- * creates a new group aggregate result if the group value has not yet
- * been encountered.
- *
- * @param tup the Tuple containing an aggregate field and a group-by field
- */
- public void mergeTupleIntoGroup(Tuple tup);
-
- /**
- * Create a DbIterator over group aggregate results.
- * @see simpledb.TupleIterator for a possible helper
- */
- public DbIterator iterator();
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/BufferPool.java b/hw/hw3/starter-code/src/java/simpledb/BufferPool.java
deleted file mode 100644
index b8a9a2d6f2cd59b743ab7e1f9c19f10eb4de42ff..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/BufferPool.java
+++ /dev/null
@@ -1,195 +0,0 @@
-package simpledb;
-
-import java.io.*;
-
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * BufferPool manages the reading and writing of pages into memory from
- * disk. Access methods call into it to retrieve pages, and it fetches
- * pages from the appropriate location.
- * <p>
- * The BufferPool is also responsible for locking; when a transaction fetches
- * a page, BufferPool checks that the transaction has the appropriate
- * locks to read/write the page.
- *
- * @Threadsafe, all fields are final
- */
-public class BufferPool {
- /** Bytes per page, including header. */
- public static final int PAGE_SIZE = 4096;
-
- private static int pageSize = PAGE_SIZE;
-
- /** Default number of pages passed to the constructor. This is used by
- other classes. BufferPool should use the numPages argument to the
- constructor instead. */
- public static final int DEFAULT_PAGES = 50;
-
- /**
- * Creates a BufferPool that caches up to numPages pages.
- *
- * @param numPages maximum number of pages in this buffer pool.
- */
- public BufferPool(int numPages) {
- // some code goes here
- }
-
- public static int getPageSize() {
- return pageSize;
- }
-
- // THIS FUNCTION SHOULD ONLY BE USED FOR TESTING!!
- public static void setPageSize(int pageSize) {
- BufferPool.pageSize = pageSize;
- }
-
- /**
- * Retrieve the specified page with the associated permissions.
- * Will acquire a lock and may block if that lock is held by another
- * transaction.
- * <p>
- * The retrieved page should be looked up in the buffer pool. If it
- * is present, it should be returned. If it is not present, it should
- * be added to the buffer pool and returned. If there is insufficient
- * space in the buffer pool, an page should be evicted and the new page
- * should be added in its place.
- *
- * @param tid the ID of the transaction requesting the page
- * @param pid the ID of the requested page
- * @param perm the requested permissions on the page
- */
- public Page getPage(TransactionId tid, PageId pid, Permissions perm)
- throws TransactionAbortedException, DbException {
- // some code goes here
- return null;
- }
-
- /**
- * Releases the lock on a page.
- * Calling this is very risky, and may result in wrong behavior. Think hard
- * about who needs to call this and why, and why they can run the risk of
- * calling it.
- *
- * @param tid the ID of the transaction requesting the unlock
- * @param pid the ID of the page to unlock
- */
- public void releasePage(TransactionId tid, PageId pid) {
- // some code goes here
- // not necessary for this assignment
- }
-
- /**
- * Release all locks associated with a given transaction.
- *
- * @param tid the ID of the transaction requesting the unlock
- */
- public void transactionComplete(TransactionId tid) throws IOException {
- // some code goes here
- // not necessary for this assignment
- }
-
- /** Return true if the specified transaction has a lock on the specified page */
- public boolean holdsLock(TransactionId tid, PageId p) {
- // some code goes here
- // not necessary for this assignment
- return false;
- }
-
- /**
- * Commit or abort a given transaction; release all locks associated to
- * the transaction.
- *
- * @param tid the ID of the transaction requesting the unlock
- * @param commit a flag indicating whether we should commit or abort
- */
- public void transactionComplete(TransactionId tid, boolean commit)
- throws IOException {
- // some code goes here
- // not necessary for this assignment
- }
-
- /**
- * Add a tuple to the specified table on behalf of transaction tid. Will
- * acquire a write lock on the page the tuple is added to and any other
- * pages that are updated (Lock acquisition is not needed for lab2).
- * May block if the lock(s) cannot be acquired.
- *
- * Marks any pages that were dirtied by the operation as dirty by calling
- * their markDirty bit, and updates cached versions of any pages that have
- * been dirtied so that future requests see up-to-date pages.
- *
- * @param tid the transaction adding the tuple
- * @param tableId the table to add the tuple to
- * @param t the tuple to add
- */
- public void insertTuple(TransactionId tid, int tableId, Tuple t)
- throws DbException, IOException, TransactionAbortedException {
- // some code goes here
- // not necessary for this assignment
- }
-
- /**
- * Remove the specified tuple from the buffer pool.
- * Will acquire a write lock on the page the tuple is removed from and any
- * other pages that are updated. May block if the lock(s) cannot be acquired.
- *
- * Marks any pages that were dirtied by the operation as dirty by calling
- * their markDirty bit, and updates cached versions of any pages that have
- * been dirtied so that future requests see up-to-date pages.
- *
- * @param tid the transaction deleting the tuple.
- * @param t the tuple to delete
- */
- public void deleteTuple(TransactionId tid, Tuple t)
- throws DbException, IOException, TransactionAbortedException {
- // some code goes here
- // not necessary for this assignment
- }
-
- /**
- * Flush all dirty pages to disk.
- * NB: Be careful using this routine -- it writes dirty data to disk so will
- * break simpledb if running in NO STEAL mode.
- */
- public synchronized void flushAllPages() throws IOException {
- // some code goes here
- // not necessary for this assignment
- }
-
- /** Remove the specific page id from the buffer pool.
- Needed by the recovery manager to ensure that the
- buffer pool doesn't keep a rolled back page in its
- cache.
- */
- public synchronized void discardPage(PageId pid) {
- // some code goes here
- // not necessary for this assignment
- }
-
- /**
- * Flushes a certain page to disk
- * @param pid an ID indicating the page to flush
- */
- private synchronized void flushPage(PageId pid) throws IOException {
- // some code goes here
- // not necessary for this assignment
- }
-
- /** Write all pages of the specified transaction to disk.
- */
- public synchronized void flushPages(TransactionId tid) throws IOException {
- // some code goes here
- // not necessary for this assignment
- }
-
- /**
- * Discards a page from the buffer pool.
- * Flushes the page to disk to ensure dirty pages are updated on disk.
- */
- private synchronized void evictPage() throws DbException {
- // some code goes here
- // not necessary for this assignment
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Catalog.java b/hw/hw3/starter-code/src/java/simpledb/Catalog.java
deleted file mode 100644
index 1b181daaf33af067c9524395e15195c96f3262c5..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Catalog.java
+++ /dev/null
@@ -1,163 +0,0 @@
-package simpledb;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileReader;
-import java.io.IOException;
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * The Catalog keeps track of all available tables in the database and their
- * associated schemas.
- * For now, this is a stub catalog that must be populated with tables by a
- * user program before it can be used -- eventually, this should be converted
- * to a catalog that reads a catalog table from disk.
- *
- * @Threadsafe
- */
-public class Catalog {
-
- /**
- * Constructor.
- * Creates a new, empty catalog.
- */
- public Catalog() {
- // some code goes here
- }
-
- /**
- * Add a new table to the catalog.
- * This table's contents are stored in the specified DbFile.
- * @param file the contents of the table to add; file.getId() is the identfier of
- * this file/tupledesc param for the calls getTupleDesc and getFile
- * @param name the name of the table -- may be an empty string. May not be null. If a name
- * conflict exists, use the last table to be added as the table for a given name.
- * @param pkeyField the name of the primary key field
- */
- public void addTable(DbFile file, String name, String pkeyField) {
- // some code goes here
- }
-
- public void addTable(DbFile file, String name) {
- addTable(file, name, "");
- }
-
- /**
- * Add a new table to the catalog.
- * This table has tuples formatted using the specified TupleDesc and its
- * contents are stored in the specified DbFile.
- * @param file the contents of the table to add; file.getId() is the identfier of
- * this file/tupledesc param for the calls getTupleDesc and getFile
- */
- public void addTable(DbFile file) {
- addTable(file, (UUID.randomUUID()).toString());
- }
-
- /**
- * Return the id of the table with a specified name,
- * @throws NoSuchElementException if the table doesn't exist
- */
- public int getTableId(String name) throws NoSuchElementException {
- // some code goes here
- return 0;
- }
-
- /**
- * Returns the tuple descriptor (schema) of the specified table
- * @param tableid The id of the table, as specified by the DbFile.getId()
- * function passed to addTable
- * @throws NoSuchElementException if the table doesn't exist
- */
- public TupleDesc getTupleDesc(int tableid) throws NoSuchElementException {
- // some code goes here
- return null;
- }
-
- /**
- * Returns the DbFile that can be used to read the contents of the
- * specified table.
- * @param tableid The id of the table, as specified by the DbFile.getId()
- * function passed to addTable
- */
- public DbFile getDatabaseFile(int tableid) throws NoSuchElementException {
- // some code goes here
- return null;
- }
-
- public String getPrimaryKey(int tableid) {
- // some code goes here
- return null;
- }
-
- public Iterator<Integer> tableIdIterator() {
- // some code goes here
- return null;
- }
-
- public String getTableName(int id) {
- // some code goes here
- return null;
- }
-
- /** Delete all tables from the catalog */
- public void clear() {
- // some code goes here
- }
-
- /**
- * Reads the schema from a file and creates the appropriate tables in the database.
- * @param catalogFile
- */
- public void loadSchema(String catalogFile) {
- String line = "";
- String baseFolder=new File(new File(catalogFile).getAbsolutePath()).getParent();
- try {
- BufferedReader br = new BufferedReader(new FileReader(new File(catalogFile)));
-
- while ((line = br.readLine()) != null) {
- //assume line is of the format name (field type, field type, ...)
- String name = line.substring(0, line.indexOf("(")).trim();
- //System.out.println("TABLE NAME: " + name);
- String fields = line.substring(line.indexOf("(") + 1, line.indexOf(")")).trim();
- String[] els = fields.split(",");
- ArrayList<String> names = new ArrayList<String>();
- ArrayList<Type> types = new ArrayList<Type>();
- String primaryKey = "";
- for (String e : els) {
- String[] els2 = e.trim().split(" ");
- names.add(els2[0].trim());
- if (els2[1].trim().toLowerCase().equals("int"))
- types.add(Type.INT_TYPE);
- else if (els2[1].trim().toLowerCase().equals("string"))
- types.add(Type.STRING_TYPE);
- else {
- System.out.println("Unknown type " + els2[1]);
- System.exit(0);
- }
- if (els2.length == 3) {
- if (els2[2].trim().equals("pk"))
- primaryKey = els2[0].trim();
- else {
- System.out.println("Unknown annotation " + els2[2]);
- System.exit(0);
- }
- }
- }
- Type[] typeAr = types.toArray(new Type[0]);
- String[] namesAr = names.toArray(new String[0]);
- TupleDesc t = new TupleDesc(typeAr, namesAr);
- HeapFile tabHf = new HeapFile(new File(baseFolder+"/"+name + ".dat"), t);
- addTable(tabHf,name,primaryKey);
- System.out.println("Added table : " + name + " with schema " + t);
- }
- } catch (IOException e) {
- e.printStackTrace();
- System.exit(0);
- } catch (IndexOutOfBoundsException e) {
- System.out.println ("Invalid catalog entry : " + line);
- System.exit(0);
- }
- }
-}
-
diff --git a/hw/hw3/starter-code/src/java/simpledb/CostCard.java b/hw/hw3/starter-code/src/java/simpledb/CostCard.java
deleted file mode 100644
index 8114a5fffceacbb6a5758005e6d51f69d4af5dcb..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/CostCard.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package simpledb;
-import java.util.Vector;
-
-/** Class returned by {@link JoinOptimizer#computeCostAndCardOfSubplan} specifying the
- cost and cardinality of the optimal plan represented by plan.
-*/
-public class CostCard {
- /** The cost of the optimal subplan */
- public double cost;
- /** The cardinality of the optimal subplan */
- public int card;
- /** The optimal subplan */
- public Vector<LogicalJoinNode> plan;
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Database.java b/hw/hw3/starter-code/src/java/simpledb/Database.java
deleted file mode 100644
index c9fc338bc7b17d06f826723bac7b06f1e57082b6..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Database.java
+++ /dev/null
@@ -1,81 +0,0 @@
-package simpledb;
-
-import java.io.*;
-import java.util.concurrent.atomic.AtomicReference;
-
-/**
- * Database is a class that initializes several static variables used by the
- * database system (the catalog, the buffer pool, and the log files, in
- * particular.)
- * <p>
- * Provides a set of methods that can be used to access these variables from
- * anywhere.
- *
- * @Threadsafe
- */
-public class Database {
- private static AtomicReference<Database> _instance = new AtomicReference<Database>(new Database());
- private final Catalog _catalog;
- private final BufferPool _bufferpool;
-
- private final static String LOGFILENAME = "log";
- private final LogFile _logfile;
-
- private Database() {
- _catalog = new Catalog();
- _bufferpool = new BufferPool(BufferPool.DEFAULT_PAGES);
- LogFile tmp = null;
- try {
- tmp = new LogFile(new File(LOGFILENAME));
- } catch (IOException e) {
- e.printStackTrace();
- System.exit(1);
- }
- _logfile = tmp;
- // startControllerThread();
- }
-
- /** Return the log file of the static Database instance */
- public static LogFile getLogFile() {
- return _instance.get()._logfile;
- }
-
- /** Return the buffer pool of the static Database instance */
- public static BufferPool getBufferPool() {
- return _instance.get()._bufferpool;
- }
-
- /** Return the catalog of the static Database instance */
- public static Catalog getCatalog() {
- return _instance.get()._catalog;
- }
-
- /**
- * Method used for testing -- create a new instance of the buffer pool and
- * return it
- */
- public static BufferPool resetBufferPool(int pages) {
- java.lang.reflect.Field bufferPoolF=null;
- try {
- bufferPoolF = Database.class.getDeclaredField("_bufferpool");
- bufferPoolF.setAccessible(true);
- bufferPoolF.set(_instance.get(), new BufferPool(pages));
- } catch (NoSuchFieldException e) {
- e.printStackTrace();
- } catch (SecurityException e) {
- e.printStackTrace();
- } catch (IllegalArgumentException e) {
- e.printStackTrace();
- } catch (IllegalAccessException e) {
- e.printStackTrace();
- }
-// _instance._bufferpool = new BufferPool(pages);
- return _instance.get()._bufferpool;
- }
-
- // reset the database, used for unit tests only.
- public static void reset() {
- _instance.set(new Database());
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/DbException.java b/hw/hw3/starter-code/src/java/simpledb/DbException.java
deleted file mode 100644
index fe23217edca03152250372f845766b0db892603f..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/DbException.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package simpledb;
-
-import java.lang.Exception;
-
-/** Generic database exception class */
-public class DbException extends Exception {
- private static final long serialVersionUID = 1L;
-
- public DbException(String s) {
- super(s);
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/DbFile.java b/hw/hw3/starter-code/src/java/simpledb/DbFile.java
deleted file mode 100644
index 294bf05bf2cb31646230424ef904c9cc5ecc4b0f..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/DbFile.java
+++ /dev/null
@@ -1,91 +0,0 @@
-
-package simpledb;
-
-import java.util.*;
-import java.io.*;
-
-/**
- * The interface for database files on disk. Each table is represented by a
- * single DbFile. DbFiles can fetch pages and iterate through tuples. Each
- * file has a unique id used to store metadata about the table in the Catalog.
- * DbFiles are generally accessed through the buffer pool, rather than directly
- * by operators.
- */
-public interface DbFile {
- /**
- * Read the specified page from disk.
- *
- * @throws IllegalArgumentException if the page does not exist in this file.
- */
- public Page readPage(PageId id);
-
- /**
- * Push the specified page to disk.
- *
- * @param p The page to write. page.getId().pageno() specifies the offset into the file where the page should be written.
- * @throws IOException if the write fails
- *
- */
- public void writePage(Page p) throws IOException;
-
- /**
- * Inserts the specified tuple to the file on behalf of transaction.
- * This method will acquire a lock on the affected pages of the file, and
- * may block until the lock can be acquired.
- *
- * @param tid The transaction performing the update
- * @param t The tuple to add. This tuple should be updated to reflect that
- * it is now stored in this file.
- * @return An ArrayList contain the pages that were modified
- * @throws DbException if the tuple cannot be added
- * @throws IOException if the needed file can't be read/written
- */
- public ArrayList<Page> insertTuple(TransactionId tid, Tuple t)
- throws DbException, IOException, TransactionAbortedException;
-
- /**
- * Removes the specified tuple from the file on behalf of the specified
- * transaction.
- * This method will acquire a lock on the affected pages of the file, and
- * may block until the lock can be acquired.
- *
- * @param tid The transaction performing the update
- * @param t The tuple to delete. This tuple should be updated to reflect that
- * it is no longer stored on any page.
- * @return An ArrayList contain the pages that were modified
- * @throws DbException if the tuple cannot be deleted or is not a member
- * of the file
- */
- public ArrayList<Page> deleteTuple(TransactionId tid, Tuple t)
- throws DbException, IOException, TransactionAbortedException;
-
- /**
- * Returns an iterator over all the tuples stored in this DbFile. The
- * iterator must use {@link BufferPool#getPage}, rather than
- * {@link #readPage} to iterate through the pages.
- *
- * @return an iterator over all the tuples stored in this DbFile.
- */
- public DbFileIterator iterator(TransactionId tid);
-
- /**
- * Returns a unique ID used to identify this DbFile in the Catalog. This id
- * can be used to look up the table via {@link Catalog#getDatabaseFile} and
- * {@link Catalog#getTupleDesc}.
- * <p>
- * Implementation note: you will need to generate this tableid somewhere,
- * ensure that each HeapFile has a "unique id," and that you always
- * return the same value for a particular HeapFile. A simple implementation
- * is to use the hash code of the absolute path of the file underlying
- * the HeapFile, i.e. <code>f.getAbsoluteFile().hashCode()</code>.
- *
- * @return an ID uniquely identifying this HeapFile.
- */
- public int getId();
-
- /**
- * Returns the TupleDesc of the table stored in this DbFile.
- * @return TupleDesc of this DbFile.
- */
- public TupleDesc getTupleDesc();
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/DbFileIterator.java b/hw/hw3/starter-code/src/java/simpledb/DbFileIterator.java
deleted file mode 100644
index cb9161eaa0bdf50d462a21a59b5ca578b93778da..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/DbFileIterator.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package simpledb;
-import java.util.*;
-
-/**
- * DbFileIterator is the iterator interface that all SimpleDB Dbfile should
- * implement.
- */
-public interface DbFileIterator{
- /**
- * Opens the iterator
- * @throws DbException when there are problems opening/accessing the database.
- */
- public void open()
- throws DbException, TransactionAbortedException;
-
- /** @return true if there are more tuples available. */
- public boolean hasNext()
- throws DbException, TransactionAbortedException;
-
- /**
- * Gets the next tuple from the operator (typically implementing by reading
- * from a child operator or an access method).
- *
- * @return The next tuple in the iterator.
- * @throws NoSuchElementException if there are no more tuples
- */
- public Tuple next()
- throws DbException, TransactionAbortedException, NoSuchElementException;
-
- /**
- * Resets the iterator to the start.
- * @throws DbException When rewind is unsupported.
- */
- public void rewind() throws DbException, TransactionAbortedException;
-
- /**
- * Closes the iterator.
- */
- public void close();
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/DbIterator.java b/hw/hw3/starter-code/src/java/simpledb/DbIterator.java
deleted file mode 100644
index 3831605ed1a2d7fb91c4ed41dfe793c1088129a4..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/DbIterator.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package simpledb;
-import java.io.Serializable;
-import java.util.*;
-
-/**
- * DbIterator is the iterator interface that all SimpleDB operators should
- * implement. If the iterator is not open, none of the methods should work,
- * and should throw an IllegalStateException. In addition to any
- * resource allocation/deallocation, an open method should call any
- * child iterator open methods, and in a close method, an iterator
- * should call its children's close methods.
- */
-public interface DbIterator extends Serializable{
- /**
- * Opens the iterator. This must be called before any of the other methods.
- * @throws DbException when there are problems opening/accessing the database.
- */
- public void open()
- throws DbException, TransactionAbortedException;
-
- /** Returns true if the iterator has more tuples.
- * @return true f the iterator has more tuples.
- * @throws IllegalStateException If the iterator has not been opened
- */
- public boolean hasNext() throws DbException, TransactionAbortedException;
-
- /**
- * Returns the next tuple from the operator (typically implementing by reading
- * from a child operator or an access method).
- *
- * @return the next tuple in the iteration.
- * @throws NoSuchElementException if there are no more tuples.
- * @throws IllegalStateException If the iterator has not been opened
- */
- public Tuple next() throws DbException, TransactionAbortedException, NoSuchElementException;
-
- /**
- * Resets the iterator to the start.
- * @throws DbException when rewind is unsupported.
- * @throws IllegalStateException If the iterator has not been opened
- */
- public void rewind() throws DbException, TransactionAbortedException;
-
- /**
- * Returns the TupleDesc associated with this DbIterator.
- * @return the TupleDesc associated with this DbIterator.
- */
- public TupleDesc getTupleDesc();
-
- /**
- * Closes the iterator. When the iterator is closed, calling next(),
- * hasNext(), or rewind() should fail by throwing IllegalStateException.
- */
- public void close();
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Debug.java b/hw/hw3/starter-code/src/java/simpledb/Debug.java
deleted file mode 100644
index 62281b5d87e6731e31663cc63fca62fdce79a6ff..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Debug.java
+++ /dev/null
@@ -1,54 +0,0 @@
-
-package simpledb;
-
-/**
- * Debug is a utility class that wraps println statements and allows
- * more or less command line output to be turned on.
- * <p>
- * Change the value of the DEBUG_LEVEL constant using a system property:
- * simpledb.Debug. For example, on the command line, use -Dsimpledb.Debug=x,
- * or simply -Dsimpledb.Debug to enable it at level 0.
- * The log(level, message, ...) method will print to standard output if the
- * level number is less than or equal to the currently set DEBUG_LEVEL.
- */
-
-public class Debug {
- private static final int DEBUG_LEVEL;
- static {
- String debug = System.getProperty("simpledb.Debug");
- if (debug == null) {
- // No system property = disabled
- DEBUG_LEVEL = -1;
- } else if (debug == "") {
- // Empty property = level 0
- DEBUG_LEVEL = 0;
- } else {
- DEBUG_LEVEL = Integer.parseInt(debug);
- }
- }
-
- private static final int DEFAULT_LEVEL = 0;
-
- /** Log message if the log level >= level. Uses printf. */
- public static void log(int level, String message, Object... args) {
- if (isEnabled(level)) {
- System.out.printf(message, args);
- System.out.println();
- }
- }
-
- /** @return true if level is being logged. */
- public static boolean isEnabled(int level) {
- return level <= DEBUG_LEVEL;
- }
-
- /** @return true if the default level is being logged. */
- public static boolean isEnabled() {
- return isEnabled(DEFAULT_LEVEL);
- }
-
- /** Logs message at the default log level. */
- public static void log(String message, Object... args) {
- log(DEFAULT_LEVEL, message, args);
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Delete.java b/hw/hw3/starter-code/src/java/simpledb/Delete.java
deleted file mode 100644
index 5532cf59557615285e885dde9378da851734853a..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Delete.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package simpledb;
-
-import java.io.IOException;
-
-/**
- * The delete operator. Delete reads tuples from its child operator and removes
- * them from the table they belong to.
- */
-public class Delete extends Operator {
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Constructor specifying the transaction that this delete belongs to as
- * well as the child to read from.
- *
- * @param t
- * The transaction this delete runs in
- * @param child
- * The child operator from which to read tuples for deletion
- */
- public Delete(TransactionId t, DbIterator child) {
- // some code goes here
- }
-
- public TupleDesc getTupleDesc() {
- // some code goes here
- return null;
- }
-
- public void open() throws DbException, TransactionAbortedException {
- // some code goes here
- }
-
- public void close() {
- // some code goes here
- }
-
- public void rewind() throws DbException, TransactionAbortedException {
- // some code goes here
- }
-
- /**
- * Deletes tuples as they are read from the child operator. Deletes are
- * processed via the buffer pool (which can be accessed via the
- * Database.getBufferPool() method.
- *
- * @return A 1-field tuple containing the number of deleted records.
- * @see Database#getBufferPool
- * @see BufferPool#deleteTuple
- */
- protected Tuple fetchNext() throws TransactionAbortedException, DbException {
- // some code goes here
- return null;
- }
-
- @Override
- public DbIterator[] getChildren() {
- // some code goes here
- return null;
- }
-
- @Override
- public void setChildren(DbIterator[] children) {
- // some code goes here
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Field.java b/hw/hw3/starter-code/src/java/simpledb/Field.java
deleted file mode 100644
index 0b872ebc8796f20c39f8c730e6aefafbbd584e0d..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Field.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package simpledb;
-
-import java.io.*;
-
-/**
- * Interface for values of fields in tuples in SimpleDB.
- */
-public interface Field extends Serializable{
- /**
- * Write the bytes representing this field to the specified
- * DataOutputStream.
- * @see DataOutputStream
- * @param dos The DataOutputStream to write to.
- */
- void serialize(DataOutputStream dos) throws IOException;
-
- /**
- * Compare the value of this field object to the passed in value.
- * @param op The operator
- * @param value The value to compare this Field to
- * @return Whether or not the comparison yields true.
- */
- public boolean compare(Predicate.Op op, Field value);
-
- /**
- * Returns the type of this field (see {@link Type#INT_TYPE} or {@link Type#STRING_TYPE}
- * @return type of this field
- */
- public Type getType();
-
- /**
- * Hash code.
- * Different Field objects representing the same value should probably
- * return the same hashCode.
- */
- public int hashCode();
- public boolean equals(Object field);
-
- public String toString();
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Filter.java b/hw/hw3/starter-code/src/java/simpledb/Filter.java
deleted file mode 100644
index dc192974ce14a583a9c98a8e4d0f60f1bcc2a414..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Filter.java
+++ /dev/null
@@ -1,74 +0,0 @@
-package simpledb;
-
-import java.util.*;
-
-/**
- * Filter is an operator that implements a relational select.
- */
-public class Filter extends Operator {
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Constructor accepts a predicate to apply and a child operator to read
- * tuples to filter from.
- *
- * @param p
- * The predicate to filter tuples with
- * @param child
- * The child operator
- */
- public Filter(Predicate p, DbIterator child) {
- // some code goes here
- }
-
- public Predicate getPredicate() {
- // some code goes here
- return null;
- }
-
- public TupleDesc getTupleDesc() {
- // some code goes here
- return null;
- }
-
- public void open() throws DbException, NoSuchElementException,
- TransactionAbortedException {
- // some code goes here
- }
-
- public void close() {
- // some code goes here
- }
-
- public void rewind() throws DbException, TransactionAbortedException {
- // some code goes here
- }
-
- /**
- * AbstractDbIterator.readNext implementation. Iterates over tuples from the
- * child operator, applying the predicate to them and returning those that
- * pass the predicate (i.e. for which the Predicate.filter() returns true.)
- *
- * @return The next tuple that passes the filter, or null if there are no
- * more tuples
- * @see Predicate#filter
- */
- protected Tuple fetchNext() throws NoSuchElementException,
- TransactionAbortedException, DbException {
- // some code goes here
- return null;
- }
-
- @Override
- public DbIterator[] getChildren() {
- // some code goes here
- return null;
- }
-
- @Override
- public void setChildren(DbIterator[] children) {
- // some code goes here
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/HeapFile.java b/hw/hw3/starter-code/src/java/simpledb/HeapFile.java
deleted file mode 100644
index dfa07b576dd0b608f9086ff82a4ef25bbb29b3d8..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/HeapFile.java
+++ /dev/null
@@ -1,106 +0,0 @@
-package simpledb;
-
-import java.io.*;
-import java.util.*;
-
-/**
- * HeapFile is an implementation of a DbFile that stores a collection of tuples
- * in no particular order. Tuples are stored on pages, each of which is a fixed
- * size, and the file is simply a collection of those pages. HeapFile works
- * closely with HeapPage. The format of HeapPages is described in the HeapPage
- * constructor.
- *
- * @see simpledb.HeapPage#HeapPage
- * @author Sam Madden
- */
-public class HeapFile implements DbFile {
-
- /**
- * Constructs a heap file backed by the specified file.
- *
- * @param f
- * the file that stores the on-disk backing store for this heap
- * file.
- */
- public HeapFile(File f, TupleDesc td) {
- // some code goes here
- }
-
- /**
- * Returns the File backing this HeapFile on disk.
- *
- * @return the File backing this HeapFile on disk.
- */
- public File getFile() {
- // some code goes here
- return null;
- }
-
- /**
- * Returns an ID uniquely identifying this HeapFile. Implementation note:
- * you will need to generate this tableid somewhere ensure that each
- * HeapFile has a "unique id," and that you always return the same value for
- * a particular HeapFile. We suggest hashing the absolute file name of the
- * file underlying the heapfile, i.e. f.getAbsoluteFile().hashCode().
- *
- * @return an ID uniquely identifying this HeapFile.
- */
- public int getId() {
- // some code goes here
- throw new UnsupportedOperationException("implement this");
- }
-
- /**
- * Returns the TupleDesc of the table stored in this DbFile.
- *
- * @return TupleDesc of this DbFile.
- */
- public TupleDesc getTupleDesc() {
- // some code goes here
- throw new UnsupportedOperationException("implement this");
- }
-
- // see DbFile.java for javadocs
- public Page readPage(PageId pid) {
- // some code goes here
- return null;
- }
-
- // see DbFile.java for javadocs
- public void writePage(Page page) throws IOException {
- // some code goes here
- // not necessary for this assignment
- }
-
- /**
- * Returns the number of pages in this HeapFile.
- */
- public int numPages() {
- // some code goes here
- return 0;
- }
-
- // see DbFile.java for javadocs
- public ArrayList<Page> insertTuple(TransactionId tid, Tuple t)
- throws DbException, IOException, TransactionAbortedException {
- // some code goes here
- // not necessary for this assignment
- return null;
- }
-
- // see DbFile.java for javadocs
- public ArrayList<Page> deleteTuple(TransactionId tid, Tuple t) throws DbException,
- TransactionAbortedException {
- // some code goes here
- // not necessary for this assignment
- return null;
- }
-
- // see DbFile.java for javadocs
- public DbFileIterator iterator(TransactionId tid) {
- // some code goes here
- return null;
- }
-
-}
-
diff --git a/hw/hw3/starter-code/src/java/simpledb/HeapFileEncoder.java b/hw/hw3/starter-code/src/java/simpledb/HeapFileEncoder.java
deleted file mode 100644
index dc575f9f1c9a464bfc329801de28941952bfadad..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/HeapFileEncoder.java
+++ /dev/null
@@ -1,226 +0,0 @@
-package simpledb;
-
-import java.io.*;
-import java.util.ArrayList;
-
-/**
- * HeapFileEncoder reads a comma delimited text file or accepts
- * an array of tuples and converts it to
- * pages of binary data in the appropriate format for simpledb heap pages
- * Pages are padded out to a specified length, and written consecutive in a
- * data file.
- */
-
-public class HeapFileEncoder {
-
- /** Convert the specified tuple list (with only integer fields) into a binary
- * page file. <br>
- *
- * The format of the output file will be as specified in HeapPage and
- * HeapFile.
- *
- * @see HeapPage
- * @see HeapFile
- * @param tuples the tuples - a list of tuples, each represented by a list of integers that are
- * the field values for that tuple.
- * @param outFile The output file to write data to
- * @param npagebytes The number of bytes per page in the output file
- * @param numFields the number of fields in each input tuple
- * @throws IOException if the temporary/output file can't be opened
- */
- public static void convert(ArrayList<ArrayList<Integer>> tuples, File outFile, int npagebytes, int numFields) throws IOException {
- File tempInput = File.createTempFile("tempTable", ".txt");
- tempInput.deleteOnExit();
- BufferedWriter bw = new BufferedWriter(new FileWriter(tempInput));
- for (ArrayList<Integer> tuple : tuples) {
- int writtenFields = 0;
- for (Integer field : tuple) {
- writtenFields++;
- if (writtenFields > numFields) {
- throw new RuntimeException("Tuple has more than " + numFields + " fields: (" +
- Utility.listToString(tuple) + ")");
- }
- bw.write(String.valueOf(field));
- if (writtenFields < numFields) {
- bw.write(',');
- }
- }
- bw.write('\n');
- }
- bw.close();
- convert(tempInput, outFile, npagebytes, numFields);
- }
-
- public static void convert(File inFile, File outFile, int npagebytes,
- int numFields) throws IOException {
- Type[] ts = new Type[numFields];
- for (int i = 0; i < ts.length; i++) {
- ts[i] = Type.INT_TYPE;
- }
- convert(inFile,outFile,npagebytes,numFields,ts);
- }
-
- public static void convert(File inFile, File outFile, int npagebytes,
- int numFields, Type[] typeAr)
- throws IOException {
- convert(inFile,outFile,npagebytes,numFields,typeAr,',');
- }
-
- /** Convert the specified input text file into a binary
- * page file. <br>
- * Assume format of the input file is (note that only integer fields are
- * supported):<br>
- * int,...,int\n<br>
- * int,...,int\n<br>
- * ...<br>
- * where each row represents a tuple.<br>
- * <p>
- * The format of the output file will be as specified in HeapPage and
- * HeapFile.
- *
- * @see HeapPage
- * @see HeapFile
- * @param inFile The input file to read data from
- * @param outFile The output file to write data to
- * @param npagebytes The number of bytes per page in the output file
- * @param numFields the number of fields in each input line/output tuple
- * @throws IOException if the input/output file can't be opened or a
- * malformed input line is encountered
- */
- public static void convert(File inFile, File outFile, int npagebytes,
- int numFields, Type[] typeAr, char fieldSeparator)
- throws IOException {
-
- int nrecbytes = 0;
- for (int i = 0; i < numFields ; i++) {
- nrecbytes += typeAr[i].getLen();
- }
- int nrecords = (npagebytes * 8) / (nrecbytes * 8 + 1); //floor comes for free
-
- // per record, we need one bit; there are nrecords per page, so we need
- // nrecords bits, i.e., ((nrecords/32)+1) integers.
- int nheaderbytes = (nrecords / 8);
- if (nheaderbytes * 8 < nrecords)
- nheaderbytes++; //ceiling
- int nheaderbits = nheaderbytes * 8;
-
- BufferedReader br = new BufferedReader(new FileReader(inFile));
- FileOutputStream os = new FileOutputStream(outFile);
-
- // our numbers probably won't be much larger than 1024 digits
- char buf[] = new char[1024];
-
- int curpos = 0;
- int recordcount = 0;
- int npages = 0;
- int fieldNo = 0;
-
- ByteArrayOutputStream headerBAOS = new ByteArrayOutputStream(nheaderbytes);
- DataOutputStream headerStream = new DataOutputStream(headerBAOS);
- ByteArrayOutputStream pageBAOS = new ByteArrayOutputStream(npagebytes);
- DataOutputStream pageStream = new DataOutputStream(pageBAOS);
-
- boolean done = false;
- boolean first = true;
- while (!done) {
- int c = br.read();
-
- // Ignore Windows/Notepad special line endings
- if (c == '\r')
- continue;
-
- if (c == '\n') {
- if (first)
- continue;
- recordcount++;
- first = true;
- } else
- first = false;
- if (c == fieldSeparator || c == '\n' || c == '\r') {
- String s = new String(buf, 0, curpos);
- if (typeAr[fieldNo] == Type.INT_TYPE) {
- try {
- pageStream.writeInt(Integer.parseInt(s.trim()));
- } catch (NumberFormatException e) {
- System.out.println ("BAD LINE : " + s);
- }
- }
- else if (typeAr[fieldNo] == Type.STRING_TYPE) {
- s = s.trim();
- int overflow = Type.STRING_LEN - s.length();
- if (overflow < 0) {
- String news = s.substring(0,Type.STRING_LEN);
- s = news;
- }
- pageStream.writeInt(s.length());
- pageStream.writeBytes(s);
- while (overflow-- > 0)
- pageStream.write((byte)0);
- }
- curpos = 0;
- if (c == '\n')
- fieldNo = 0;
- else
- fieldNo++;
-
- } else if (c == -1) {
- done = true;
-
- } else {
- buf[curpos++] = (char)c;
- continue;
- }
-
- // if we wrote a full page of records, or if we're done altogether,
- // write out the header of the page.
- //
- // in the header, write a 1 for bits that correspond to records we've
- // written and 0 for empty slots.
- //
- // when we're done, also flush the page to disk, but only if it has
- // records on it. however, if this file is empty, do flush an empty
- // page to disk.
- if (recordcount >= nrecords
- || done && recordcount > 0
- || done && npages == 0) {
- int i = 0;
- byte headerbyte = 0;
-
- for (i=0; i<nheaderbits; i++) {
- if (i < recordcount)
- headerbyte |= (1 << (i % 8));
-
- if (((i+1) % 8) == 0) {
- headerStream.writeByte(headerbyte);
- headerbyte = 0;
- }
- }
-
- if (i % 8 > 0)
- headerStream.writeByte(headerbyte);
-
- // pad the rest of the page with zeroes
-
- for (i=0; i<(npagebytes - (recordcount * nrecbytes + nheaderbytes)); i++)
- pageStream.writeByte(0);
-
- // write header and body to file
- headerStream.flush();
- headerBAOS.writeTo(os);
- pageStream.flush();
- pageBAOS.writeTo(os);
-
- // reset header and body for next page
- headerBAOS = new ByteArrayOutputStream(nheaderbytes);
- headerStream = new DataOutputStream(headerBAOS);
- pageBAOS = new ByteArrayOutputStream(npagebytes);
- pageStream = new DataOutputStream(pageBAOS);
-
- recordcount = 0;
- npages++;
- }
- }
- br.close();
- os.close();
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/HeapPage.java b/hw/hw3/starter-code/src/java/simpledb/HeapPage.java
deleted file mode 100644
index 126e85430d3c6d3598267787545002801295f53b..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/HeapPage.java
+++ /dev/null
@@ -1,303 +0,0 @@
-package simpledb;
-
-import java.util.*;
-import java.io.*;
-
-/**
- * Each instance of HeapPage stores data for one page of HeapFiles and
- * implements the Page interface that is used by BufferPool.
- *
- * @see HeapFile
- * @see BufferPool
- *
- */
-public class HeapPage implements Page {
-
- final HeapPageId pid;
- final TupleDesc td;
- final byte header[];
- final Tuple tuples[];
- final int numSlots;
-
- byte[] oldData;
- private final Byte oldDataLock=new Byte((byte)0);
-
- /**
- * Create a HeapPage from a set of bytes of data read from disk.
- * The format of a HeapPage is a set of header bytes indicating
- * the slots of the page that are in use, some number of tuple slots.
- * Specifically, the number of tuples is equal to: <p>
- * floor((BufferPool.getPageSize()*8) / (tuple size * 8 + 1))
- * <p> where tuple size is the size of tuples in this
- * database table, which can be determined via {@link Catalog#getTupleDesc}.
- * The number of 8-bit header words is equal to:
- * <p>
- * ceiling(no. tuple slots / 8)
- * <p>
- * @see Database#getCatalog
- * @see Catalog#getTupleDesc
- * @see BufferPool#getPageSize()
- */
- public HeapPage(HeapPageId id, byte[] data) throws IOException {
- this.pid = id;
- this.td = Database.getCatalog().getTupleDesc(id.getTableId());
- this.numSlots = getNumTuples();
- DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data));
-
- // allocate and read the header slots of this page
- header = new byte[getHeaderSize()];
- for (int i=0; i<header.length; i++)
- header[i] = dis.readByte();
-
- tuples = new Tuple[numSlots];
- try{
- // allocate and read the actual records of this page
- for (int i=0; i<tuples.length; i++)
- tuples[i] = readNextTuple(dis,i);
- }catch(NoSuchElementException e){
- e.printStackTrace();
- }
- dis.close();
-
- setBeforeImage();
- }
-
- /** Retrieve the number of tuples on this page.
- @return the number of tuples on this page
- */
- private int getNumTuples() {
- // some code goes here
- return 0;
-
- }
-
- /**
- * Computes the number of bytes in the header of a page in a HeapFile with each tuple occupying tupleSize bytes
- * @return the number of bytes in the header of a page in a HeapFile with each tuple occupying tupleSize bytes
- */
- private int getHeaderSize() {
-
- // some code goes here
- return 0;
-
- }
-
- /** Return a view of this page before it was modified
- -- used by recovery */
- public HeapPage getBeforeImage(){
- // not necessary for this assignment
- return null;
- }
-
- public void setBeforeImage() {
- synchronized(oldDataLock)
- {
- oldData = getPageData().clone();
- }
- }
-
- /**
- * @return the PageId associated with this page.
- */
- public HeapPageId getId() {
- // some code goes here
- throw new UnsupportedOperationException("implement this");
- }
-
- /**
- * Suck up tuples from the source file.
- */
- private Tuple readNextTuple(DataInputStream dis, int slotId) throws NoSuchElementException {
- // if associated bit is not set, read forward to the next tuple, and
- // return null.
- if (!isSlotUsed(slotId)) {
- for (int i=0; i<td.getSize(); i++) {
- try {
- dis.readByte();
- } catch (IOException e) {
- throw new NoSuchElementException("error reading empty tuple");
- }
- }
- return null;
- }
-
- // read fields in the tuple
- Tuple t = new Tuple(td);
- RecordId rid = new RecordId(pid, slotId);
- t.setRecordId(rid);
- try {
- for (int j=0; j<td.numFields(); j++) {
- Field f = td.getFieldType(j).parse(dis);
- t.setField(j, f);
- }
- } catch (java.text.ParseException e) {
- e.printStackTrace();
- throw new NoSuchElementException("parsing error!");
- }
-
- return t;
- }
-
- /**
- * Generates a byte array representing the contents of this page.
- * Used to serialize this page to disk.
- * <p>
- * The invariant here is that it should be possible to pass the byte
- * array generated by getPageData to the HeapPage constructor and
- * have it produce an identical HeapPage object.
- *
- * @see #HeapPage
- * @return A byte array correspond to the bytes of this page.
- */
- public byte[] getPageData() {
- int len = BufferPool.getPageSize();
- ByteArrayOutputStream baos = new ByteArrayOutputStream(len);
- DataOutputStream dos = new DataOutputStream(baos);
-
- // create the header of the page
- for (int i=0; i<header.length; i++) {
- try {
- dos.writeByte(header[i]);
- } catch (IOException e) {
- // this really shouldn't happen
- e.printStackTrace();
- }
- }
-
- // create the tuples
- for (int i=0; i<tuples.length; i++) {
-
- // empty slot
- if (!isSlotUsed(i)) {
- for (int j=0; j<td.getSize(); j++) {
- try {
- dos.writeByte(0);
- } catch (IOException e) {
- e.printStackTrace();
- }
-
- }
- continue;
- }
-
- // non-empty slot
- for (int j=0; j<td.numFields(); j++) {
- Field f = tuples[i].getField(j);
- try {
- f.serialize(dos);
-
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
- }
-
- // padding
- int zerolen = BufferPool.getPageSize() - (header.length + td.getSize() * tuples.length); //- numSlots * td.getSize();
- byte[] zeroes = new byte[zerolen];
- try {
- dos.write(zeroes, 0, zerolen);
- } catch (IOException e) {
- e.printStackTrace();
- }
-
- try {
- dos.flush();
- } catch (IOException e) {
- e.printStackTrace();
- }
-
- return baos.toByteArray();
- }
-
- /**
- * Static method to generate a byte array corresponding to an empty
- * HeapPage.
- * Used to add new, empty pages to the file. Passing the results of
- * this method to the HeapPage constructor will create a HeapPage with
- * no valid tuples in it.
- *
- * @return The returned ByteArray.
- */
- public static byte[] createEmptyPageData() {
- int len = BufferPool.getPageSize();
- return new byte[len]; //all 0
- }
-
- /**
- * Delete the specified tuple from the page; the tuple should be updated to reflect
- * that it is no longer stored on any page.
- * @throws DbException if this tuple is not on this page, or tuple slot is
- * already empty.
- * @param t The tuple to delete
- */
- public void deleteTuple(Tuple t) throws DbException {
- // some code goes here
- // not necessary for this assignment
- }
-
- /**
- * Adds the specified tuple to the page; the tuple should be updated to reflect
- * that it is now stored on this page.
- * @throws DbException if the page is full (no empty slots) or tupledesc
- * is mismatch.
- * @param t The tuple to add.
- */
- public void insertTuple(Tuple t) throws DbException {
- // some code goes here
- // not necessary for this assignment
- }
-
- /**
- * Marks this page as dirty/not dirty and record that transaction
- * that did the dirtying
- */
- public void markDirty(boolean dirty, TransactionId tid) {
- // some code goes here
- // not necessary for this assignment
- }
-
- /**
- * Returns the tid of the transaction that last dirtied this page, or null if the page is not dirty
- */
- public TransactionId isDirty() {
- // some code goes here
- // not necessary for this assignment
- return null;
- }
-
- /**
- * Returns the number of empty slots on this page.
- */
- public int getNumEmptySlots() {
- // some code goes here
- return 0;
- }
-
- /**
- * Returns true if associated slot on this page is filled.
- */
- public boolean isSlotUsed(int i) {
- // some code goes here
- return false;
- }
-
- /**
- * Abstraction to fill or clear a slot on this page.
- */
- private void markSlotUsed(int i, boolean value) {
- // some code goes here
- // not necessary for this assignment
- }
-
- /**
- * @return an iterator over all tuples on this page (calling remove on this iterator throws an UnsupportedOperationException)
- * (note that this iterator shouldn't return tuples in empty slots!)
- */
- public Iterator<Tuple> iterator() {
- // some code goes here
- return null;
- }
-
-}
-
diff --git a/hw/hw3/starter-code/src/java/simpledb/HeapPageId.java b/hw/hw3/starter-code/src/java/simpledb/HeapPageId.java
deleted file mode 100644
index 670a4764153a04c00dc1cf7a749602b0f1dfdc76..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/HeapPageId.java
+++ /dev/null
@@ -1,70 +0,0 @@
-package simpledb;
-
-/** Unique identifier for HeapPage objects. */
-public class HeapPageId implements PageId {
-
- /**
- * Constructor. Create a page id structure for a specific page of a
- * specific table.
- *
- * @param tableId The table that is being referenced
- * @param pgNo The page number in that table.
- */
- public HeapPageId(int tableId, int pgNo) {
- // some code goes here
- }
-
- /** @return the table associated with this PageId */
- public int getTableId() {
- // some code goes here
- return 0;
- }
-
- /**
- * @return the page number in the table getTableId() associated with
- * this PageId
- */
- public int pageNumber() {
- // some code goes here
- return 0;
- }
-
- /**
- * @return a hash code for this page, represented by the concatenation of
- * the table number and the page number (needed if a PageId is used as a
- * key in a hash table in the BufferPool, for example.)
- * @see BufferPool
- */
- public int hashCode() {
- // some code goes here
- throw new UnsupportedOperationException("implement this");
- }
-
- /**
- * Compares one PageId to another.
- *
- * @param o The object to compare against (must be a PageId)
- * @return true if the objects are equal (e.g., page numbers and table
- * ids are the same)
- */
- public boolean equals(Object o) {
- // some code goes here
- return false;
- }
-
- /**
- * Return a representation of this object as an array of
- * integers, for writing to disk. Size of returned array must contain
- * number of integers that corresponds to number of args to one of the
- * constructors.
- */
- public int[] serialize() {
- int data[] = new int[2];
-
- data[0] = getTableId();
- data[1] = pageNumber();
-
- return data;
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Insert.java b/hw/hw3/starter-code/src/java/simpledb/Insert.java
deleted file mode 100644
index 4d7c587a20e4b1181db74ce4b31c95371fc72b84..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Insert.java
+++ /dev/null
@@ -1,74 +0,0 @@
-package simpledb;
-
-/**
- * Inserts tuples read from the child operator into the tableid specified in the
- * constructor
- */
-public class Insert extends Operator {
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Constructor.
- *
- * @param t
- * The transaction running the insert.
- * @param child
- * The child operator from which to read tuples to be inserted.
- * @param tableid
- * The table in which to insert tuples.
- * @throws DbException
- * if TupleDesc of child differs from table into which we are to
- * insert.
- */
- public Insert(TransactionId t,DbIterator child, int tableid)
- throws DbException {
- // some code goes here
- }
-
- public TupleDesc getTupleDesc() {
- // some code goes here
- return null;
- }
-
- public void open() throws DbException, TransactionAbortedException {
- // some code goes here
- }
-
- public void close() {
- // some code goes here
- }
-
- public void rewind() throws DbException, TransactionAbortedException {
- // some code goes here
- }
-
- /**
- * Inserts tuples read from child into the tableid specified by the
- * constructor. It returns a one field tuple containing the number of
- * inserted records. Inserts should be passed through BufferPool. An
- * instances of BufferPool is available via Database.getBufferPool(). Note
- * that insert DOES NOT need check to see if a particular tuple is a
- * duplicate before inserting it.
- *
- * @return A 1-field tuple containing the number of inserted records, or
- * null if called more than once.
- * @see Database#getBufferPool
- * @see BufferPool#insertTuple
- */
- protected Tuple fetchNext() throws TransactionAbortedException, DbException {
- // some code goes here
- return null;
- }
-
- @Override
- public DbIterator[] getChildren() {
- // some code goes here
- return null;
- }
-
- @Override
- public void setChildren(DbIterator[] children) {
- // some code goes here
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/IntField.java b/hw/hw3/starter-code/src/java/simpledb/IntField.java
deleted file mode 100644
index e4fbd5c48bce4c7424872b7f2f7933394575fcf4..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/IntField.java
+++ /dev/null
@@ -1,86 +0,0 @@
-package simpledb;
-
-import java.io.*;
-
-/**
- * Instance of Field that stores a single integer.
- */
-public class IntField implements Field {
-
- private static final long serialVersionUID = 1L;
-
- private final int value;
-
- public int getValue() {
- return value;
- }
-
- /**
- * Constructor.
- *
- * @param i The value of this field.
- */
- public IntField(int i) {
- value = i;
- }
-
- public String toString() {
- return Integer.toString(value);
- }
-
- public int hashCode() {
- return value;
- }
-
- public boolean equals(Object field) {
- return ((IntField) field).value == value;
- }
-
- public void serialize(DataOutputStream dos) throws IOException {
- dos.writeInt(value);
- }
-
- /**
- * Compare the specified field to the value of this Field.
- * Return semantics are as specified by Field.compare
- *
- * @throws IllegalCastException if val is not an IntField
- * @see Field#compare
- */
- public boolean compare(Predicate.Op op, Field val) {
-
- IntField iVal = (IntField) val;
-
- switch (op) {
- case EQUALS:
- return value == iVal.value;
- case NOT_EQUALS:
- return value != iVal.value;
-
- case GREATER_THAN:
- return value > iVal.value;
-
- case GREATER_THAN_OR_EQ:
- return value >= iVal.value;
-
- case LESS_THAN:
- return value < iVal.value;
-
- case LESS_THAN_OR_EQ:
- return value <= iVal.value;
-
- case LIKE:
- return value == iVal.value;
- }
-
- return false;
- }
-
- /**
- * Return the Type of this field.
- * @return Type.INT_TYPE
- */
- public Type getType() {
- return Type.INT_TYPE;
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/IntegerAggregator.java b/hw/hw3/starter-code/src/java/simpledb/IntegerAggregator.java
deleted file mode 100644
index ce2dcff4c5d14a5325ca9bb5574c495d5fd253b0..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/IntegerAggregator.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package simpledb;
-
-/**
- * Knows how to compute some aggregate over a set of IntFields.
- */
-public class IntegerAggregator implements Aggregator {
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Aggregate constructor
- *
- * @param gbfield
- * the 0-based index of the group-by field in the tuple, or
- * NO_GROUPING if there is no grouping
- * @param gbfieldtype
- * the type of the group by field (e.g., Type.INT_TYPE), or null
- * if there is no grouping
- * @param afield
- * the 0-based index of the aggregate field in the tuple
- * @param what
- * the aggregation operator
- */
-
- public IntegerAggregator(int gbfield, Type gbfieldtype, int afield, Op what) {
- // some code goes here
- }
-
- /**
- * Merge a new tuple into the aggregate, grouping as indicated in the
- * constructor
- *
- * @param tup
- * the Tuple containing an aggregate field and a group-by field
- */
- public void mergeTupleIntoGroup(Tuple tup) {
- // some code goes here
- }
-
- /**
- * Create a DbIterator over group aggregate results.
- *
- * @return a DbIterator whose tuples are the pair (groupVal, aggregateVal)
- * if using group, or a single (aggregateVal) if no grouping. The
- * aggregateVal is determined by the type of aggregate specified in
- * the constructor.
- */
- public DbIterator iterator() {
- // some code goes here
- throw new
- UnsupportedOperationException("please implement me for lab2");
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Join.java b/hw/hw3/starter-code/src/java/simpledb/Join.java
deleted file mode 100644
index d85c7ba6746b6ce67e46ae515ccb9c9e9aebdeca..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Join.java
+++ /dev/null
@@ -1,108 +0,0 @@
-package simpledb;
-
-import java.util.*;
-
-/**
- * The Join operator implements the relational join operation.
- */
-public class Join extends Operator {
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Constructor. Accepts to children to join and the predicate to join them
- * on
- *
- * @param p
- * The predicate to use to join the children
- * @param child1
- * Iterator for the left(outer) relation to join
- * @param child2
- * Iterator for the right(inner) relation to join
- */
- public Join(JoinPredicate p, DbIterator child1, DbIterator child2) {
- // some code goes here
- }
-
- public JoinPredicate getJoinPredicate() {
- // some code goes here
- return null;
- }
-
- /**
- * @return
- * the field name of join field1. Should be quantified by
- * alias or table name.
- * */
- public String getJoinField1Name() {
- // some code goes here
- return null;
- }
-
- /**
- * @return
- * the field name of join field2. Should be quantified by
- * alias or table name.
- * */
- public String getJoinField2Name() {
- // some code goes here
- return null;
- }
-
- /**
- * @see simpledb.TupleDesc#merge(TupleDesc, TupleDesc) for possible
- * implementation logic.
- */
- public TupleDesc getTupleDesc() {
- // some code goes here
- return null;
- }
-
- public void open() throws DbException, NoSuchElementException,
- TransactionAbortedException {
- // some code goes here
- }
-
- public void close() {
- // some code goes here
- }
-
- public void rewind() throws DbException, TransactionAbortedException {
- // some code goes here
- }
-
- /**
- * Returns the next tuple generated by the join, or null if there are no
- * more tuples. Logically, this is the next tuple in r1 cross r2 that
- * satisfies the join predicate. There are many possible implementations;
- * the simplest is a nested loops join.
- * <p>
- * Note that the tuples returned from this particular implementation of Join
- * are simply the concatenation of joining tuples from the left and right
- * relation. Therefore, if an equality predicate is used there will be two
- * copies of the join attribute in the results. (Removing such duplicate
- * columns can be done with an additional projection operator if needed.)
- * <p>
- * For example, if one tuple is {1,2,3} and the other tuple is {1,5,6},
- * joined on equality of the first column, then this returns {1,2,3,1,5,6}.
- *
- * @return The next matching tuple.
- * @see JoinPredicate#filter
- */
- protected Tuple fetchNext() throws TransactionAbortedException, DbException {
- // some code goes here
- return null;
- }
-
- @Override
- public DbIterator[] getChildren() {
- // some code goes here
- return null;
- }
-
- @Override
- public void setChildren(DbIterator[] children) {
- // some code goes here
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/JoinOptimizer.java b/hw/hw3/starter-code/src/java/simpledb/JoinOptimizer.java
deleted file mode 100644
index d3ad836a4ac0f513f921145094e4aa2bf05727b7..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/JoinOptimizer.java
+++ /dev/null
@@ -1,557 +0,0 @@
-package simpledb;
-
-import java.util.*;
-
-import javax.swing.*;
-import javax.swing.tree.*;
-
-/**
- * The JoinOptimizer class is responsible for ordering a series of joins
- * optimally, and for selecting the best instantiation of a join for a given
- * logical plan.
- */
-public class JoinOptimizer {
- LogicalPlan p;
- Vector<LogicalJoinNode> joins;
-
- /**
- * Constructor
- *
- * @param p
- * the logical plan being optimized
- * @param joins
- * the list of joins being performed
- */
- public JoinOptimizer(LogicalPlan p, Vector<LogicalJoinNode> joins) {
- this.p = p;
- this.joins = joins;
- }
-
- /**
- * Return best iterator for computing a given logical join, given the
- * specified statistics, and the provided left and right subplans. Note that
- * there is insufficient information to determine which plan should be the
- * inner/outer here -- because DbIterator's don't provide any cardinality
- * estimates, and stats only has information about the base tables. For this
- * reason, the plan1
- *
- * @param lj
- * The join being considered
- * @param plan1
- * The left join node's child
- * @param plan2
- * The right join node's child
- */
- public static DbIterator instantiateJoin(LogicalJoinNode lj,
- DbIterator plan1, DbIterator plan2) throws ParsingException {
-
- int t1id = 0, t2id = 0;
- DbIterator j;
-
- try {
- t1id = plan1.getTupleDesc().fieldNameToIndex(lj.f1QuantifiedName);
- } catch (NoSuchElementException e) {
- throw new ParsingException("Unknown field " + lj.f1QuantifiedName);
- }
-
- if (lj instanceof LogicalSubplanJoinNode) {
- t2id = 0;
- } else {
- try {
- t2id = plan2.getTupleDesc().fieldNameToIndex(
- lj.f2QuantifiedName);
- } catch (NoSuchElementException e) {
- throw new ParsingException("Unknown field "
- + lj.f2QuantifiedName);
- }
- }
-
- JoinPredicate p = new JoinPredicate(t1id, lj.p, t2id);
-
- j = new Join(p,plan1,plan2);
-
- return j;
-
- }
-
- /**
- * Estimate the cost of a join.
- *
- * The cost of the join should be calculated based on the join algorithm (or
- * algorithms) that you implemented for Lab 2. It should be a function of
- * the amount of data that must be read over the course of the query, as
- * well as the number of CPU opertions performed by your join. Assume that
- * the cost of a single predicate application is roughly 1.
- *
- *
- * @param j
- * A LogicalJoinNode representing the join operation being
- * performed.
- * @param card1
- * Estimated cardinality of the left-hand side of the query
- * @param card2
- * Estimated cardinality of the right-hand side of the query
- * @param cost1
- * Estimated cost of one full scan of the table on the left-hand
- * side of the query
- * @param cost2
- * Estimated cost of one full scan of the table on the right-hand
- * side of the query
- * @return An estimate of the cost of this query, in terms of cost1 and
- * cost2
- */
- public double estimateJoinCost(LogicalJoinNode j, int card1, int card2,
- double cost1, double cost2) {
- if (j instanceof LogicalSubplanJoinNode) {
- // A LogicalSubplanJoinNode represents a subquery.
- // You do not need to implement proper support for these for Lab 4.
- return card1 + cost1 + cost2;
- } else {
- // Insert your code here.
- // HINT: You may need to use the variable "j" if you implemented
- // a join algorithm that's more complicated than a basic
- // nested-loops join.
- return -1.0;
- }
- }
-
- /**
- * Estimate the cardinality of a join. The cardinality of a join is the
- * number of tuples produced by the join.
- *
- * @param j
- * A LogicalJoinNode representing the join operation being
- * performed.
- * @param card1
- * Cardinality of the left-hand table in the join
- * @param card2
- * Cardinality of the right-hand table in the join
- * @param t1pkey
- * Is the left-hand table a primary-key table?
- * @param t2pkey
- * Is the right-hand table a primary-key table?
- * @param stats
- * The table stats, referenced by table names, not alias
- * @return The cardinality of the join
- */
- public int estimateJoinCardinality(LogicalJoinNode j, int card1, int card2,
- boolean t1pkey, boolean t2pkey, Map<String, TableStats> stats) {
- if (j instanceof LogicalSubplanJoinNode) {
- // A LogicalSubplanJoinNode represents a subquery.
- // You do not need to implement proper support for these for Lab 4.
- return card1;
- } else {
- return estimateTableJoinCardinality(j.p, j.t1Alias, j.t2Alias,
- j.f1PureName, j.f2PureName, card1, card2, t1pkey, t2pkey,
- stats, p.getTableAliasToIdMapping());
- }
- }
-
- /**
- * Estimate the join cardinality of two tables.
- * */
- public static int estimateTableJoinCardinality(Predicate.Op joinOp,
- String table1Alias, String table2Alias, String field1PureName,
- String field2PureName, int card1, int card2, boolean t1pkey,
- boolean t2pkey, Map<String, TableStats> stats,
- Map<String, Integer> tableAliasToId) {
- int card = 1;
- // some code goes here
- return card <= 0 ? 1 : card;
- }
-
- /**
- * Helper method to enumerate all of the subsets of a given size of a
- * specified vector.
- *
- * @param v
- * The vector whose subsets are desired
- * @param size
- * The size of the subsets of interest
- * @return a set of all subsets of the specified size
- */
- @SuppressWarnings("unchecked")
- public <T> Set<Set<T>> enumerateSubsets(Vector<T> v, int size) {
- Set<Set<T>> els = new HashSet<Set<T>>();
- els.add(new HashSet<T>());
- // Iterator<Set> it;
- // long start = System.currentTimeMillis();
-
- for (int i = 0; i < size; i++) {
- Set<Set<T>> newels = new HashSet<Set<T>>();
- for (Set<T> s : els) {
- for (T t : v) {
- Set<T> news = (Set<T>) (((HashSet<T>) s).clone());
- if (news.add(t))
- newels.add(news);
- }
- }
- els = newels;
- }
-
- return els;
-
- }
-
- /**
- * Compute a logical, reasonably efficient join on the specified tables. See
- * PS4 for hints on how this should be implemented.
- *
- * @param stats
- * Statistics for each table involved in the join, referenced by
- * base table names, not alias
- * @param filterSelectivities
- * Selectivities of the filter predicates on each table in the
- * join, referenced by table alias (if no alias, the base table
- * name)
- * @param explain
- * Indicates whether your code should explain its query plan or
- * simply execute it
- * @return A Vector<LogicalJoinNode> that stores joins in the left-deep
- * order in which they should be executed.
- * @throws ParsingException
- * when stats or filter selectivities is missing a table in the
- * join, or or when another internal error occurs
- */
- public Vector<LogicalJoinNode> orderJoins(
- HashMap<String, TableStats> stats,
- HashMap<String, Double> filterSelectivities, boolean explain)
- throws ParsingException {
- //Not necessary for labs 1--3
-
- // See the Lab 4 writeup for some hints as to how this function
- // should work.
-
- // some code goes here
- //Replace the following
- return joins;
- }
-
- // ===================== Private Methods =================================
-
- /**
- * This is a helper method that computes the cost and cardinality of joining
- * joinToRemove to joinSet (joinSet should contain joinToRemove), given that
- * all of the subsets of size joinSet.size() - 1 have already been computed
- * and stored in PlanCache pc.
- *
- * @param stats
- * table stats for all of the tables, referenced by table names
- * rather than alias (see {@link #orderJoins})
- * @param filterSelectivities
- * the selectivities of the filters over each of the tables
- * (where tables are indentified by their alias or name if no
- * alias is given)
- * @param joinToRemove
- * the join to remove from joinSet
- * @param joinSet
- * the set of joins being considered
- * @param bestCostSoFar
- * the best way to join joinSet so far (minimum of previous
- * invocations of computeCostAndCardOfSubplan for this joinSet,
- * from returned CostCard)
- * @param pc
- * the PlanCache for this join; should have subplans for all
- * plans of size joinSet.size()-1
- * @return A {@link CostCard} objects desribing the cost, cardinality,
- * optimal subplan
- * @throws ParsingException
- * when stats, filterSelectivities, or pc object is missing
- * tables involved in join
- */
- @SuppressWarnings("unchecked")
- private CostCard computeCostAndCardOfSubplan(
- HashMap<String, TableStats> stats,
- HashMap<String, Double> filterSelectivities,
- LogicalJoinNode joinToRemove, Set<LogicalJoinNode> joinSet,
- double bestCostSoFar, PlanCache pc) throws ParsingException {
-
- LogicalJoinNode j = joinToRemove;
-
- Vector<LogicalJoinNode> prevBest;
-
- if (this.p.getTableId(j.t1Alias) == null)
- throw new ParsingException("Unknown table " + j.t1Alias);
- if (this.p.getTableId(j.t2Alias) == null)
- throw new ParsingException("Unknown table " + j.t2Alias);
-
- String table1Name = Database.getCatalog().getTableName(
- this.p.getTableId(j.t1Alias));
- String table2Name = Database.getCatalog().getTableName(
- this.p.getTableId(j.t2Alias));
- String table1Alias = j.t1Alias;
- String table2Alias = j.t2Alias;
-
- Set<LogicalJoinNode> news = (Set<LogicalJoinNode>) ((HashSet<LogicalJoinNode>) joinSet)
- .clone();
- news.remove(j);
-
- double t1cost, t2cost;
- int t1card, t2card;
- boolean leftPkey, rightPkey;
-
- if (news.isEmpty()) { // base case -- both are base relations
- prevBest = new Vector<LogicalJoinNode>();
- t1cost = stats.get(table1Name).estimateScanCost();
- t1card = stats.get(table1Name).estimateTableCardinality(
- filterSelectivities.get(j.t1Alias));
- leftPkey = isPkey(j.t1Alias, j.f1PureName);
-
- t2cost = table2Alias == null ? 0 : stats.get(table2Name)
- .estimateScanCost();
- t2card = table2Alias == null ? 0 : stats.get(table2Name)
- .estimateTableCardinality(
- filterSelectivities.get(j.t2Alias));
- rightPkey = table2Alias == null ? false : isPkey(table2Alias,
- j.f2PureName);
- } else {
- // news is not empty -- figure best way to join j to news
- prevBest = pc.getOrder(news);
-
- // possible that we have not cached an answer, if subset
- // includes a cross product
- if (prevBest == null) {
- return null;
- }
-
- double prevBestCost = pc.getCost(news);
- int bestCard = pc.getCard(news);
-
- // estimate cost of right subtree
- if (doesJoin(prevBest, table1Alias)) { // j.t1 is in prevBest
- t1cost = prevBestCost; // left side just has cost of whatever
- // left
- // subtree is
- t1card = bestCard;
- leftPkey = hasPkey(prevBest);
-
- t2cost = j.t2Alias == null ? 0 : stats.get(table2Name)
- .estimateScanCost();
- t2card = j.t2Alias == null ? 0 : stats.get(table2Name)
- .estimateTableCardinality(
- filterSelectivities.get(j.t2Alias));
- rightPkey = j.t2Alias == null ? false : isPkey(j.t2Alias,
- j.f2PureName);
- } else if (doesJoin(prevBest, j.t2Alias)) { // j.t2 is in prevbest
- // (both
- // shouldn't be)
- t2cost = prevBestCost; // left side just has cost of whatever
- // left
- // subtree is
- t2card = bestCard;
- rightPkey = hasPkey(prevBest);
-
- t1cost = stats.get(table1Name).estimateScanCost();
- t1card = stats.get(table1Name).estimateTableCardinality(
- filterSelectivities.get(j.t1Alias));
- leftPkey = isPkey(j.t1Alias, j.f1PureName);
-
- } else {
- // don't consider this plan if one of j.t1 or j.t2
- // isn't a table joined in prevBest (cross product)
- return null;
- }
- }
-
- // case where prevbest is left
- double cost1 = estimateJoinCost(j, t1card, t2card, t1cost, t2cost);
-
- LogicalJoinNode j2 = j.swapInnerOuter();
- double cost2 = estimateJoinCost(j2, t2card, t1card, t2cost, t1cost);
- if (cost2 < cost1) {
- boolean tmp;
- j = j2;
- cost1 = cost2;
- tmp = rightPkey;
- rightPkey = leftPkey;
- leftPkey = tmp;
- }
- if (cost1 >= bestCostSoFar)
- return null;
-
- CostCard cc = new CostCard();
-
- cc.card = estimateJoinCardinality(j, t1card, t2card, leftPkey,
- rightPkey, stats);
- cc.cost = cost1;
- cc.plan = (Vector<LogicalJoinNode>) prevBest.clone();
- cc.plan.addElement(j); // prevbest is left -- add new join to end
- return cc;
- }
-
- /**
- * Return true if the specified table is in the list of joins, false
- * otherwise
- */
- private boolean doesJoin(Vector<LogicalJoinNode> joinlist, String table) {
- for (LogicalJoinNode j : joinlist) {
- if (j.t1Alias.equals(table)
- || (j.t2Alias != null && j.t2Alias.equals(table)))
- return true;
- }
- return false;
- }
-
- /**
- * Return true if field is a primary key of the specified table, false
- * otherwise
- *
- * @param tableAlias
- * The alias of the table in the query
- * @param field
- * The pure name of the field
- */
- private boolean isPkey(String tableAlias, String field) {
- int tid1 = p.getTableId(tableAlias);
- String pkey1 = Database.getCatalog().getPrimaryKey(tid1);
-
- return pkey1.equals(field);
- }
-
- /**
- * Return true if a primary key field is joined by one of the joins in
- * joinlist
- */
- private boolean hasPkey(Vector<LogicalJoinNode> joinlist) {
- for (LogicalJoinNode j : joinlist) {
- if (isPkey(j.t1Alias, j.f1PureName)
- || (j.t2Alias != null && isPkey(j.t2Alias, j.f2PureName)))
- return true;
- }
- return false;
-
- }
-
- /**
- * Helper function to display a Swing window with a tree representation of
- * the specified list of joins. See {@link #orderJoins}, which may want to
- * call this when the analyze flag is true.
- *
- * @param js
- * the join plan to visualize
- * @param pc
- * the PlanCache accumulated whild building the optimal plan
- * @param stats
- * table statistics for base tables
- * @param selectivities
- * the selectivities of the filters over each of the tables
- * (where tables are indentified by their alias or name if no
- * alias is given)
- */
- private void printJoins(Vector<LogicalJoinNode> js, PlanCache pc,
- HashMap<String, TableStats> stats,
- HashMap<String, Double> selectivities) {
-
- JFrame f = new JFrame("Join Plan for " + p.getQuery());
-
- // Set the default close operation for the window,
- // or else the program won't exit when clicking close button
- f.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
-
- f.setVisible(true);
-
- f.setSize(300, 500);
-
- HashMap<String, DefaultMutableTreeNode> m = new HashMap<String, DefaultMutableTreeNode>();
-
- // int numTabs = 0;
-
- // int k;
- DefaultMutableTreeNode root = null, treetop = null;
- HashSet<LogicalJoinNode> pathSoFar = new HashSet<LogicalJoinNode>();
- boolean neither;
-
- System.out.println(js);
- for (LogicalJoinNode j : js) {
- pathSoFar.add(j);
- System.out.println("PATH SO FAR = " + pathSoFar);
-
- String table1Name = Database.getCatalog().getTableName(
- this.p.getTableId(j.t1Alias));
- String table2Name = Database.getCatalog().getTableName(
- this.p.getTableId(j.t2Alias));
-
- // Double c = pc.getCost(pathSoFar);
- neither = true;
-
- root = new DefaultMutableTreeNode("Join " + j + " (Cost ="
- + pc.getCost(pathSoFar) + ", card = "
- + pc.getCard(pathSoFar) + ")");
- DefaultMutableTreeNode n = m.get(j.t1Alias);
- if (n == null) { // never seen this table before
- n = new DefaultMutableTreeNode(j.t1Alias
- + " (Cost = "
- + stats.get(table1Name).estimateScanCost()
- + ", card = "
- + stats.get(table1Name).estimateTableCardinality(
- selectivities.get(j.t1Alias)) + ")");
- root.add(n);
- } else {
- // make left child root n
- root.add(n);
- neither = false;
- }
- m.put(j.t1Alias, root);
-
- n = m.get(j.t2Alias);
- if (n == null) { // never seen this table before
-
- n = new DefaultMutableTreeNode(
- j.t2Alias == null ? "Subplan"
- : (j.t2Alias
- + " (Cost = "
- + stats.get(table2Name)
- .estimateScanCost()
- + ", card = "
- + stats.get(table2Name)
- .estimateTableCardinality(
- selectivities
- .get(j.t2Alias)) + ")"));
- root.add(n);
- } else {
- // make right child root n
- root.add(n);
- neither = false;
- }
- m.put(j.t2Alias, root);
-
- // unless this table doesn't join with other tables,
- // all tables are accessed from root
- if (!neither) {
- for (String key : m.keySet()) {
- m.put(key, root);
- }
- }
-
- treetop = root;
- }
-
- JTree tree = new JTree(treetop);
- JScrollPane treeView = new JScrollPane(tree);
-
- tree.setShowsRootHandles(true);
-
- // Set the icon for leaf nodes.
- ImageIcon leafIcon = new ImageIcon("join.jpg");
- DefaultTreeCellRenderer renderer = new DefaultTreeCellRenderer();
- renderer.setOpenIcon(leafIcon);
- renderer.setClosedIcon(leafIcon);
-
- tree.setCellRenderer(renderer);
-
- f.setSize(300, 500);
-
- f.add(treeView);
- for (int i = 0; i < tree.getRowCount(); i++) {
- tree.expandRow(i);
- }
-
- if (js.size() == 0) {
- f.add(new JLabel("No joins in plan."));
- }
-
- f.pack();
-
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/JoinPredicate.java b/hw/hw3/starter-code/src/java/simpledb/JoinPredicate.java
deleted file mode 100644
index 2ca767245d9eca7db49a34422fee7ff4925f330e..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/JoinPredicate.java
+++ /dev/null
@@ -1,59 +0,0 @@
-package simpledb;
-
-import java.io.Serializable;
-
-/**
- * JoinPredicate compares fields of two tuples using a predicate. JoinPredicate
- * is most likely used by the Join operator.
- */
-public class JoinPredicate implements Serializable {
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Constructor -- create a new predicate over two fields of two tuples.
- *
- * @param field1
- * The field index into the first tuple in the predicate
- * @param field2
- * The field index into the second tuple in the predicate
- * @param op
- * The operation to apply (as defined in Predicate.Op); either
- * Predicate.Op.GREATER_THAN, Predicate.Op.LESS_THAN,
- * Predicate.Op.EQUAL, Predicate.Op.GREATER_THAN_OR_EQ, or
- * Predicate.Op.LESS_THAN_OR_EQ
- * @see Predicate
- */
- public JoinPredicate(int field1, Predicate.Op op, int field2) {
- // some code goes here
- }
-
- /**
- * Apply the predicate to the two specified tuples. The comparison can be
- * made through Field's compare method.
- *
- * @return true if the tuples satisfy the predicate.
- */
- public boolean filter(Tuple t1, Tuple t2) {
- // some code goes here
- return false;
- }
-
- public int getField1()
- {
- // some code goes here
- return -1;
- }
-
- public int getField2()
- {
- // some code goes here
- return -1;
- }
-
- public Predicate.Op getOperator()
- {
- // some code goes here
- return null;
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/LogFile.java b/hw/hw3/starter-code/src/java/simpledb/LogFile.java
deleted file mode 100644
index f46053601d3245c7a29dc3696e61fe71bbb24575..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/LogFile.java
+++ /dev/null
@@ -1,510 +0,0 @@
-
-package simpledb;
-
-import java.io.*;
-import java.util.*;
-import java.lang.reflect.*;
-
-/**
-LogFile implements the recovery subsystem of SimpleDb. This class is
-able to write different log records as needed, but it is the
-responsibility of the caller to ensure that write ahead logging and
-two-phase locking discipline are followed. <p>
-
-<u> Locking note: </u>
-<p>
-
-Many of the methods here are synchronized (to prevent concurrent log
-writes from happening); many of the methods in BufferPool are also
-synchronized (for similar reasons.) Problem is that BufferPool writes
-log records (on page flushed) and the log file flushes BufferPool
-pages (on checkpoints and recovery.) This can lead to deadlock. For
-that reason, any LogFile operation that needs to access the BufferPool
-must not be declared synchronized and must begin with a block like:
-
-<p>
-<pre>
- synchronized (Database.getBufferPool()) {
- synchronized (this) {
-
- ..
-
- }
- }
-</pre>
-*/
-
-/**
-<p> The format of the log file is as follows:
-
-<ul>
-
-<li> The first long integer of the file represents the offset of the
-last written checkpoint, or -1 if there are no checkpoints
-
-<li> All additional data in the log consists of log records. Log
-records are variable length.
-
-<li> Each log record begins with an integer type and a long integer
-transaction id.
-
-<li> Each log record ends with a long integer file offset representing
-the position in the log file where the record began.
-
-<li> There are five record types: ABORT, COMMIT, UPDATE, BEGIN, and
-CHECKPOINT
-
-<li> ABORT, COMMIT, and BEGIN records contain no additional data
-
-<li>UPDATE RECORDS consist of two entries, a before image and an
-after image. These images are serialized Page objects, and can be
-accessed with the LogFile.readPageData() and LogFile.writePageData()
-methods. See LogFile.print() for an example.
-
-<li> CHECKPOINT records consist of active transactions at the time
-the checkpoint was taken and their first log record on disk. The format
-of the record is an integer count of the number of transactions, as well
-as a long integer transaction id and a long integer first record offset
-for each active transaction.
-
-</ul>
-
-*/
-
-public class LogFile {
-
- final File logFile;
- private RandomAccessFile raf;
- Boolean recoveryUndecided; // no call to recover() and no append to log
-
- static final int ABORT_RECORD = 1;
- static final int COMMIT_RECORD = 2;
- static final int UPDATE_RECORD = 3;
- static final int BEGIN_RECORD = 4;
- static final int CHECKPOINT_RECORD = 5;
- static final long NO_CHECKPOINT_ID = -1;
-
- final static int INT_SIZE = 4;
- final static int LONG_SIZE = 8;
-
- long currentOffset = -1;//protected by this
-// int pageSize;
- int totalRecords = 0; // for PatchTest //protected by this
-
- HashMap<Long,Long> tidToFirstLogRecord = new HashMap<Long,Long>();
-
- /** Constructor.
- Initialize and back the log file with the specified file.
- We're not sure yet whether the caller is creating a brand new DB,
- in which case we should ignore the log file, or whether the caller
- will eventually want to recover (after populating the Catalog).
- So we make this decision lazily: if someone calls recover(), then
- do it, while if someone starts adding log file entries, then first
- throw out the initial log file contents.
-
- @param f The log file's name
- */
- public LogFile(File f) throws IOException {
- this.logFile = f;
- raf = new RandomAccessFile(f, "rw");
- recoveryUndecided = true;
-
- // install shutdown hook to force cleanup on close
- // Runtime.getRuntime().addShutdownHook(new Thread() {
- // public void run() { shutdown(); }
- // });
-
- //XXX WARNING -- there is nothing that verifies that the specified
- // log file actually corresponds to the current catalog.
- // This could cause problems since we log tableids, which may or
- // may not match tableids in the current catalog.
- }
-
- // we're about to append a log record. if we weren't sure whether the
- // DB wants to do recovery, we're sure now -- it didn't. So truncate
- // the log.
- void preAppend() throws IOException {
- totalRecords++;
- if(recoveryUndecided){
- recoveryUndecided = false;
- raf.seek(0);
- raf.setLength(0);
- raf.writeLong(NO_CHECKPOINT_ID);
- raf.seek(raf.length());
- currentOffset = raf.getFilePointer();
- }
- }
-
- public synchronized int getTotalRecords() {
- return totalRecords;
- }
-
- /** Write an abort record to the log for the specified tid, force
- the log to disk, and perform a rollback
- @param tid The aborting transaction.
- */
- public void logAbort(TransactionId tid) throws IOException {
- // must have buffer pool lock before proceeding, since this
- // calls rollback
-
- synchronized (Database.getBufferPool()) {
-
- synchronized(this) {
- preAppend();
- //Debug.log("ABORT");
- //should we verify that this is a live transaction?
-
- // must do this here, since rollback only works for
- // live transactions (needs tidToFirstLogRecord)
- rollback(tid);
-
- raf.writeInt(ABORT_RECORD);
- raf.writeLong(tid.getId());
- raf.writeLong(currentOffset);
- currentOffset = raf.getFilePointer();
- force();
- tidToFirstLogRecord.remove(tid.getId());
- }
- }
- }
-
- /** Write a commit record to disk for the specified tid,
- and force the log to disk.
-
- @param tid The committing transaction.
- */
- public synchronized void logCommit(TransactionId tid) throws IOException {
- preAppend();
- Debug.log("COMMIT " + tid.getId());
- //should we verify that this is a live transaction?
-
- raf.writeInt(COMMIT_RECORD);
- raf.writeLong(tid.getId());
- raf.writeLong(currentOffset);
- currentOffset = raf.getFilePointer();
- force();
- tidToFirstLogRecord.remove(tid.getId());
- }
-
- /** Write an UPDATE record to disk for the specified tid and page
- (with provided before and after images.)
- @param tid The transaction performing the write
- @param before The before image of the page
- @param after The after image of the page
-
- @see simpledb.Page#getBeforeImage
- */
- public synchronized void logWrite(TransactionId tid, Page before,
- Page after)
- throws IOException {
- Debug.log("WRITE, offset = " + raf.getFilePointer());
- preAppend();
- /* update record conists of
-
- record type
- transaction id
- before page data (see writePageData)
- after page data
- start offset
- */
- raf.writeInt(UPDATE_RECORD);
- raf.writeLong(tid.getId());
-
- writePageData(raf,before);
- writePageData(raf,after);
- raf.writeLong(currentOffset);
- currentOffset = raf.getFilePointer();
-
- Debug.log("WRITE OFFSET = " + currentOffset);
- }
-
- void writePageData(RandomAccessFile raf, Page p) throws IOException{
- PageId pid = p.getId();
- int pageInfo[] = pid.serialize();
-
- //page data is:
- // page class name
- // id class name
- // id class bytes
- // id class data
- // page class bytes
- // page class data
-
- String pageClassName = p.getClass().getName();
- String idClassName = pid.getClass().getName();
-
- raf.writeUTF(pageClassName);
- raf.writeUTF(idClassName);
-
- raf.writeInt(pageInfo.length);
- for (int i = 0; i < pageInfo.length; i++) {
- raf.writeInt(pageInfo[i]);
- }
- byte[] pageData = p.getPageData();
- raf.writeInt(pageData.length);
- raf.write(pageData);
- // Debug.log ("WROTE PAGE DATA, CLASS = " + pageClassName + ", table = " + pid.getTableId() + ", page = " + pid.pageno());
- }
-
- Page readPageData(RandomAccessFile raf) throws IOException {
- PageId pid;
- Page newPage = null;
-
- String pageClassName = raf.readUTF();
- String idClassName = raf.readUTF();
-
- try {
- Class<?> idClass = Class.forName(idClassName);
- Class<?> pageClass = Class.forName(pageClassName);
-
- Constructor<?>[] idConsts = idClass.getDeclaredConstructors();
- int numIdArgs = raf.readInt();
- Object idArgs[] = new Object[numIdArgs];
- for (int i = 0; i<numIdArgs;i++) {
- idArgs[i] = new Integer(raf.readInt());
- }
- pid = (PageId)idConsts[0].newInstance(idArgs);
-
- Constructor<?>[] pageConsts = pageClass.getDeclaredConstructors();
- int pageSize = raf.readInt();
-
- byte[] pageData = new byte[pageSize];
- raf.read(pageData); //read before image
-
- Object[] pageArgs = new Object[2];
- pageArgs[0] = pid;
- pageArgs[1] = pageData;
-
- newPage = (Page)pageConsts[0].newInstance(pageArgs);
-
- // Debug.log("READ PAGE OF TYPE " + pageClassName + ", table = " + newPage.getId().getTableId() + ", page = " + newPage.getId().pageno());
- } catch (ClassNotFoundException e){
- e.printStackTrace();
- throw new IOException();
- } catch (InstantiationException e) {
- e.printStackTrace();
- throw new IOException();
- } catch (IllegalAccessException e) {
- e.printStackTrace();
- throw new IOException();
- } catch (InvocationTargetException e) {
- e.printStackTrace();
- throw new IOException();
- }
- return newPage;
-
- }
-
- /** Write a BEGIN record for the specified transaction
- @param tid The transaction that is beginning
-
- */
- public synchronized void logXactionBegin(TransactionId tid)
- throws IOException {
- Debug.log("BEGIN");
- if(tidToFirstLogRecord.get(tid.getId()) != null){
- System.err.printf("logXactionBegin: already began this tid\n");
- throw new IOException("double logXactionBegin()");
- }
- preAppend();
- raf.writeInt(BEGIN_RECORD);
- raf.writeLong(tid.getId());
- raf.writeLong(currentOffset);
- tidToFirstLogRecord.put(tid.getId(), currentOffset);
- currentOffset = raf.getFilePointer();
-
- Debug.log("BEGIN OFFSET = " + currentOffset);
- }
-
- /** Checkpoint the log and write a checkpoint record. */
- public void logCheckpoint() throws IOException {
- //make sure we have buffer pool lock before proceeding
- synchronized (Database.getBufferPool()) {
- synchronized (this) {
- //Debug.log("CHECKPOINT, offset = " + raf.getFilePointer());
- preAppend();
- long startCpOffset, endCpOffset;
- Set<Long> keys = tidToFirstLogRecord.keySet();
- Iterator<Long> els = keys.iterator();
- force();
- Database.getBufferPool().flushAllPages();
- startCpOffset = raf.getFilePointer();
- raf.writeInt(CHECKPOINT_RECORD);
- raf.writeLong(-1); //no tid , but leave space for convenience
-
- //write list of outstanding transactions
- raf.writeInt(keys.size());
- while (els.hasNext()) {
- Long key = els.next();
- Debug.log("WRITING CHECKPOINT TRANSACTION ID: " + key);
- raf.writeLong(key);
- //Debug.log("WRITING CHECKPOINT TRANSACTION OFFSET: " + tidToFirstLogRecord.get(key));
- raf.writeLong(tidToFirstLogRecord.get(key));
- }
-
- //once the CP is written, make sure the CP location at the
- // beginning of the log file is updated
- endCpOffset = raf.getFilePointer();
- raf.seek(0);
- raf.writeLong(startCpOffset);
- raf.seek(endCpOffset);
- raf.writeLong(currentOffset);
- currentOffset = raf.getFilePointer();
- //Debug.log("CP OFFSET = " + currentOffset);
- }
- }
-
- logTruncate();
- }
-
- /** Truncate any unneeded portion of the log to reduce its space
- consumption */
- public synchronized void logTruncate() throws IOException {
- preAppend();
- raf.seek(0);
- long cpLoc = raf.readLong();
-
- long minLogRecord = cpLoc;
-
- if (cpLoc != -1L) {
- raf.seek(cpLoc);
- int cpType = raf.readInt();
- @SuppressWarnings("unused")
- long cpTid = raf.readLong();
-
- if (cpType != CHECKPOINT_RECORD) {
- throw new RuntimeException("Checkpoint pointer does not point to checkpoint record");
- }
-
- int numOutstanding = raf.readInt();
-
- for (int i = 0; i < numOutstanding; i++) {
- @SuppressWarnings("unused")
- long tid = raf.readLong();
- long firstLogRecord = raf.readLong();
- if (firstLogRecord < minLogRecord) {
- minLogRecord = firstLogRecord;
- }
- }
- }
-
- // we can truncate everything before minLogRecord
- File newFile = new File("logtmp" + System.currentTimeMillis());
- RandomAccessFile logNew = new RandomAccessFile(newFile, "rw");
- logNew.seek(0);
- logNew.writeLong((cpLoc - minLogRecord) + LONG_SIZE);
-
- raf.seek(minLogRecord);
-
- //have to rewrite log records since offsets are different after truncation
- while (true) {
- try {
- int type = raf.readInt();
- long record_tid = raf.readLong();
- long newStart = logNew.getFilePointer();
-
- Debug.log("NEW START = " + newStart);
-
- logNew.writeInt(type);
- logNew.writeLong(record_tid);
-
- switch (type) {
- case UPDATE_RECORD:
- Page before = readPageData(raf);
- Page after = readPageData(raf);
-
- writePageData(logNew, before);
- writePageData(logNew, after);
- break;
- case CHECKPOINT_RECORD:
- int numXactions = raf.readInt();
- logNew.writeInt(numXactions);
- while (numXactions-- > 0) {
- long xid = raf.readLong();
- long xoffset = raf.readLong();
- logNew.writeLong(xid);
- logNew.writeLong((xoffset - minLogRecord) + LONG_SIZE);
- }
- break;
- case BEGIN_RECORD:
- tidToFirstLogRecord.put(record_tid,newStart);
- break;
- }
-
- //all xactions finish with a pointer
- logNew.writeLong(newStart);
- raf.readLong();
-
- } catch (EOFException e) {
- break;
- }
- }
-
- Debug.log("TRUNCATING LOG; WAS " + raf.length() + " BYTES ; NEW START : " + minLogRecord + " NEW LENGTH: " + (raf.length() - minLogRecord));
-
- raf.close();
- logFile.delete();
- newFile.renameTo(logFile);
- raf = new RandomAccessFile(logFile, "rw");
- raf.seek(raf.length());
- newFile.delete();
-
- currentOffset = raf.getFilePointer();
- //print();
- }
-
- /** Rollback the specified transaction, setting the state of any
- of pages it updated to their pre-updated state. To preserve
- transaction semantics, this should not be called on
- transactions that have already committed (though this may not
- be enforced by this method.)
-
- @param tid The transaction to rollback
- */
- public void rollback(TransactionId tid)
- throws NoSuchElementException, IOException {
- synchronized (Database.getBufferPool()) {
- synchronized(this) {
- preAppend();
- // some code goes here
- }
- }
- }
-
- /** Shutdown the logging system, writing out whatever state
- is necessary so that start up can happen quickly (without
- extensive recovery.)
- */
- public synchronized void shutdown() {
- try {
- logCheckpoint(); //simple way to shutdown is to write a checkpoint record
- raf.close();
- } catch (IOException e) {
- System.out.println("ERROR SHUTTING DOWN -- IGNORING.");
- e.printStackTrace();
- }
- }
-
- /** Recover the database system by ensuring that the updates of
- committed transactions are installed and that the
- updates of uncommitted transactions are not installed.
- */
- public void recover() throws IOException {
- synchronized (Database.getBufferPool()) {
- synchronized (this) {
- recoveryUndecided = false;
- // some code goes here
- }
- }
- }
-
- /** Print out a human readable represenation of the log */
- public void print() throws IOException {
- // some code goes here
- }
-
- public synchronized void force() throws IOException {
- raf.getChannel().force(true);
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/LogicalFilterNode.java b/hw/hw3/starter-code/src/java/simpledb/LogicalFilterNode.java
deleted file mode 100644
index d3b59085efa714a0fba6dd788f0772f1814f39b9..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/LogicalFilterNode.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package simpledb;
-
-/** A LogicalFilterNode represents the parameters of a filter in the WHERE clause of a query.
- <p>
- Filter is of the form t.f p c
- <p>
- Where t is a table, f is a field in t, p is a predicate, and c is a constant
-*/
-public class LogicalFilterNode {
- /** The alias of a table (or the name if no alias) over which the filter ranges */
- public String tableAlias;
-
- /** The predicate in the filter */
- public Predicate.Op p;
-
- /* The constant on the right side of the filter */
- public String c;
-
- /** The field from t which is in the filter. The pure name, without alias or tablename*/
- public String fieldPureName;
-
- public String fieldQuantifiedName;
-
- public LogicalFilterNode(String table, String field, Predicate.Op pred, String constant) {
- tableAlias = table;
- p = pred;
- c = constant;
- String[] tmps = field.split("[.]");
- if (tmps.length>1)
- fieldPureName = tmps[tmps.length-1];
- else
- fieldPureName=field;
- this.fieldQuantifiedName = tableAlias+"."+fieldPureName;
- }
-}
\ No newline at end of file
diff --git a/hw/hw3/starter-code/src/java/simpledb/LogicalJoinNode.java b/hw/hw3/starter-code/src/java/simpledb/LogicalJoinNode.java
deleted file mode 100644
index f81cb26ac19286ef2ecbae45aa95b0078f71a3cf..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/LogicalJoinNode.java
+++ /dev/null
@@ -1,79 +0,0 @@
-package simpledb;
-
-/** A LogicalJoinNode represens the state needed of a join of two
- * tables in a LogicalQueryPlan */
-public class LogicalJoinNode {
-
- /** The first table to join (may be null). It's the alias of the table (if no alias, the true table name) */
- public String t1Alias;
-
- /** The second table to join (may be null). It's the alias of the table, (if no alias, the true table name).*/
- public String t2Alias;
-
- /** The name of the field in t1 to join with. It's the pure name of a field, rather that alias.field. */
- public String f1PureName;
-
- public String f1QuantifiedName;
-
- /** The name of the field in t2 to join with. It's the pure name of a field.*/
- public String f2PureName;
-
- public String f2QuantifiedName;
-
- /** The join predicate */
- public Predicate.Op p;
-
- public LogicalJoinNode() {
- }
-
- public LogicalJoinNode(String table1, String table2, String joinField1, String joinField2, Predicate.Op pred) {
- t1Alias = table1;
- t2Alias = table2;
- String[] tmps = joinField1.split("[.]");
- if (tmps.length>1)
- f1PureName = tmps[tmps.length-1];
- else
- f1PureName=joinField1;
- tmps = joinField2.split("[.]");
- if (tmps.length>1)
- f2PureName = tmps[tmps.length-1];
- else
- f2PureName = joinField2;
- p = pred;
- this.f1QuantifiedName = t1Alias+"."+this.f1PureName;
- this.f2QuantifiedName = t2Alias+"."+this.f2PureName;
- }
-
- /** Return a new LogicalJoinNode with the inner and outer (t1.f1
- * and t2.f2) tables swapped. */
- public LogicalJoinNode swapInnerOuter() {
- Predicate.Op newp;
- if (p == Predicate.Op.GREATER_THAN)
- newp = Predicate.Op.LESS_THAN;
- else if (p == Predicate.Op.GREATER_THAN_OR_EQ)
- newp = Predicate.Op.LESS_THAN_OR_EQ;
- else if (p == Predicate.Op.LESS_THAN)
- newp = Predicate.Op.GREATER_THAN;
- else if (p == Predicate.Op.LESS_THAN_OR_EQ)
- newp = Predicate.Op.GREATER_THAN_OR_EQ;
- else
- newp = p;
-
- LogicalJoinNode j2 = new LogicalJoinNode(t2Alias,t1Alias,f2PureName,f1PureName, newp);
- return j2;
- }
-
- @Override public boolean equals(Object o) {
- LogicalJoinNode j2 =(LogicalJoinNode)o;
- return (j2.t1Alias.equals(t1Alias) || j2.t1Alias.equals(t2Alias)) && (j2.t2Alias.equals(t1Alias) || j2.t2Alias.equals(t2Alias));
- }
-
- @Override public String toString() {
- return t1Alias + ":" + t2Alias ;//+ ";" + f1 + " " + p + " " + f2;
- }
-
- @Override public int hashCode() {
- return t1Alias.hashCode() + t2Alias.hashCode() + f1PureName.hashCode() + f2PureName.hashCode();
- }
-}
-
diff --git a/hw/hw3/starter-code/src/java/simpledb/LogicalPlan.java b/hw/hw3/starter-code/src/java/simpledb/LogicalPlan.java
deleted file mode 100644
index 6809a8e287997f38b13e3f9a04680d4e3df5586c..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/LogicalPlan.java
+++ /dev/null
@@ -1,546 +0,0 @@
-package simpledb;
-import java.util.Map;
-import java.util.Vector;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.io.File;
-import java.util.ArrayList;
-import java.util.NoSuchElementException;
-
-/**
- * LogicalPlan represents a logical query plan that has been through
- * the parser and is ready to be processed by the optimizer.
- * <p>
- * A LogicalPlan consits of a collection of table scan nodes, join
- * nodes, filter nodes, a select list, and a group by field.
- * LogicalPlans can only represent queries with one aggregation field
- * and one group by field.
- * <p>
- * LogicalPlans can be converted to physical (optimized) plans using
- * the {@link #physicalPlan} method, which uses the
- * {@link JoinOptimizer} to order joins optimally and to select the
- * best implementations for joins.
- */
-public class LogicalPlan {
- private Vector<LogicalJoinNode> joins;
- private Vector<LogicalScanNode> tables;
- private Vector<LogicalFilterNode> filters;
- private HashMap<String,DbIterator> subplanMap;
- private HashMap<String,Integer> tableMap;
-
- private Vector<LogicalSelectListNode> selectList;
- private String groupByField = null;
- private boolean hasAgg = false;
- private String aggOp;
- private String aggField;
- private boolean oByAsc, hasOrderBy = false;
- private String oByField;
- private String query;
-// private Query owner;
-
- /** Constructor -- generate an empty logical plan */
- public LogicalPlan() {
- joins = new Vector<LogicalJoinNode>();
- filters = new Vector<LogicalFilterNode>();
- tables = new Vector<LogicalScanNode>();
- subplanMap = new HashMap<String,DbIterator>();
- tableMap = new HashMap<String,Integer>();
-
- selectList = new Vector<LogicalSelectListNode>();
- this.query = "";
- }
-
- /** Set the text of the query representing this logical plan. Does NOT parse the
- specified query -- this method is just used so that the object can print the
- SQL it represents.
-
- @param query the text of the query associated with this plan
- */
- public void setQuery(String query) {
- this.query = query;
- }
-
- /** Get the query text associated with this plan via {@link #setQuery}.
- */
- public String getQuery() {
- return query;
- }
-
- /** Given a table alias, return id of the table object (this id can be supplied to {@link Catalog#getDatabaseFile(int)}).
- Aliases are added as base tables are added via {@link #addScan}.
-
- @param alias the table alias to return a table id for
- @return the id of the table corresponding to alias, or null if the alias is unknown
- */
- public Integer getTableId(String alias) {
- return tableMap.get(alias);
- }
-
- public HashMap<String,Integer> getTableAliasToIdMapping()
- {
- return this.tableMap;
- }
-
- /** Add a new filter to the logical plan
- * @param field The name of the over which the filter applies;
- * this can be a fully qualified field (tablename.field or
- * alias.field), or can be a unique field name without a
- * tablename qualifier. If it is an ambiguous name, it will
- * throw a ParsingException
- * @param p The predicate for the filter
- * @param constantValue the constant to compare the predicate
- * against; if field is an integer field, this should be a
- * String representing an integer
- * @throws ParsingException if field is not in one of the tables
- * added via {@link #addScan} or if field is ambiguous (e.g., two
- * tables contain a field named field.)
- */
- public void addFilter(String field, Predicate.Op p, String
- constantValue) throws ParsingException{
-
- field = disambiguateName(field);
- String table = field.split("[.]")[0];
-
- LogicalFilterNode lf = new LogicalFilterNode(table, field.split("[.]")[1], p, constantValue);
- filters.addElement(lf);
- }
-
- /** Add a join between two fields of two different tables.
- * @param joinField1 The name of the first join field; this can
- * be a fully qualified name (e.g., tableName.field or
- * alias.field) or may be an unqualified unique field name. If
- * the name is ambiguous or unknown, a ParsingException will be
- * thrown.
- * @param joinField2 The name of the second join field
- * @param pred The join predicate
- * @throws ParsingException if either of the fields is ambiguous,
- * or is not in one of the tables added via {@link #addScan}
- */
-
- public void addJoin( String joinField1, String joinField2, Predicate.Op pred) throws ParsingException {
- joinField1 = disambiguateName(joinField1);
- joinField2 = disambiguateName(joinField2);
- String table1Alias = joinField1.split("[.]")[0];
- String table2Alias = joinField2.split("[.]")[0];
- String pureField1 = joinField1.split("[.]")[1];
- String pureField2 = joinField2.split("[.]")[1];
-
- if (table1Alias.equals(table2Alias))
- throw new ParsingException("Cannot join on two fields from same table");
- LogicalJoinNode lj = new LogicalJoinNode(table1Alias,table2Alias,pureField1, pureField2, pred);
- System.out.println("Added join between " + joinField1 + " and " + joinField2);
- joins.addElement(lj);
-
- }
-
- /** Add a join between a field and a subquery.
- * @param joinField1 The name of the first join field; this can
- * be a fully qualified name (e.g., tableName.field or
- * alias.field) or may be an unqualified unique field name. If
- * the name is ambiguous or unknown, a ParsingException will be
- * thrown.
- * @param joinField2 the subquery to join with -- the join field
- * of the subquery is the first field in the result set of the query
- * @param pred The join predicate.
- * @throws ParsingException if either of the fields is ambiguous,
- * or is not in one of the tables added via {@link #addScan}
- */
- public void addJoin( String joinField1, DbIterator joinField2, Predicate.Op pred) throws ParsingException {
- joinField1 = disambiguateName(joinField1);
-
- String table1 = joinField1.split("[.]")[0];
- String pureField = joinField1.split("[.]")[1];
-
- LogicalSubplanJoinNode lj = new LogicalSubplanJoinNode(table1,pureField, joinField2, pred);
- System.out.println("Added subplan join on " + joinField1);
- joins.addElement(lj);
- }
-
- /** Add a scan to the plan. One scan node needs to be added for each alias of a table
- accessed by the plan.
- @param table the id of the table accessed by the plan (can be resolved to a DbFile using {@link Catalog#getDatabaseFile}
- @param name the alias of the table in the plan
- */
-
- public void addScan(int table, String name) {
- System.out.println("Added scan of table " + name);
- tables.addElement(new LogicalScanNode(table,name));
- tableMap.put(name,table);
- }
-
- /** Add a specified field/aggregate combination to the select list of the query.
- Fields are output by the query such that the rightmost field is the first added via addProjectField.
- @param fname the field to add to the output
- @param aggOp the aggregate operation over the field.
- * @throws ParsingException
- */
- public void addProjectField(String fname, String aggOp) throws ParsingException {
- fname=disambiguateName(fname);
- if (fname.equals("*"))
- fname="null.*";
- System.out.println("Added select list field " + fname);
- if (aggOp != null) {
- System.out.println("\t with aggregator " + aggOp);
- }
- selectList.addElement(new LogicalSelectListNode(aggOp, fname));
- }
-
- /** Add an aggregate over the field with the specified grouping to
- the query. SimpleDb only supports a single aggregate
- expression and GROUP BY field.
- @param op the aggregation operator
- @param afield the field to aggregate over
- @param gfield the field to group by
- * @throws ParsingException
- */
- public void addAggregate(String op, String afield, String gfield) throws ParsingException {
- afield=disambiguateName(afield);
- if (gfield!=null)
- gfield=disambiguateName(gfield);
- aggOp = op;
- aggField = afield;
- groupByField = gfield;
- hasAgg = true;
- }
-
- /** Add an ORDER BY expression in the specified order on the specified field. SimpleDb only supports
- a single ORDER BY field.
- @param field the field to order by
- @param asc true if should be ordered in ascending order, false for descending order
- * @throws ParsingException
- */
- public void addOrderBy(String field, boolean asc) throws ParsingException {
- field=disambiguateName(field);
- oByField = field;
- oByAsc = asc;
- hasOrderBy = true;
- }
-
- /** Given a name of a field, try to figure out what table it belongs to by looking
- * through all of the tables added via {@link #addScan}.
- * @return A fully qualified name of the form tableAlias.name. If the name parameter is already qualified
- * with a table name, simply returns name.
- * @throws ParsingException if the field cannot be found in any of the tables, or if the
- * field is ambiguous (appears in multiple tables)
- */
- String disambiguateName(String name) throws ParsingException {
-
- String[] fields = name.split("[.]");
- if (fields.length == 2 && (!fields[0].equals("null")))
- return name;
- if (fields.length > 2)
- throw new ParsingException("Field " + name + " is not a valid field reference.");
- if (fields.length == 2)
- name = fields[1];
- if (name.equals("*")) return name;
- //now look for occurrences of name in all of the tables
- Iterator<LogicalScanNode> tableIt = tables.iterator();
- String tableName = null;
- while (tableIt.hasNext()) {
- LogicalScanNode table = tableIt.next();
- try {
- TupleDesc td = Database.getCatalog().getDatabaseFile(table.t).getTupleDesc();
-// int id =
- td.fieldNameToIndex(name);
- if (tableName == null) {
- tableName = table.alias;
- } else {
- throw new ParsingException("Field " + name + " appears in multiple tables; disambiguate by referring to it as tablename." + name);
- }
- } catch (NoSuchElementException e) {
- //ignore
- }
- }
- if (tableName != null)
- return tableName + "." + name;
- else
- throw new ParsingException("Field " + name + " does not appear in any tables.");
-
- }
-
- /** Convert the aggregate operator name s into an Aggregator.op operation.
- * @throws ParsingException if s is not a valid operator name
- */
- static Aggregator.Op getAggOp(String s) throws ParsingException {
- s = s.toUpperCase();
- if (s.equals("AVG")) return Aggregator.Op.AVG;
- if (s.equals("SUM")) return Aggregator.Op.SUM;
- if (s.equals("COUNT")) return Aggregator.Op.COUNT;
- if (s.equals("MIN")) return Aggregator.Op.MIN;
- if (s.equals("MAX")) return Aggregator.Op.MAX;
- throw new ParsingException("Unknown predicate " + s);
- }
-
- /** Convert this LogicalPlan into a physicalPlan represented by a {@link DbIterator}. Attempts to
- * find the optimal plan by using {@link JoinOptimizer#orderJoins} to order the joins in the plan.
- * @param t The transaction that the returned DbIterator will run as a part of
- * @param baseTableStats a HashMap providing a {@link TableStats}
- * object for each table used in the LogicalPlan. This should
- * have one entry for each table referenced by the plan, not one
- * entry for each table alias (so a table t aliases as t1 and
- * t2 would have just one entry with key 't' in this HashMap).
- * @param explain flag indicating whether output visualizing the physical
- * query plan should be given.
- * @throws ParsingException if the logical plan is not valid
- * @return A DbIterator representing this plan.
- */
- public DbIterator physicalPlan(TransactionId t, Map<String,TableStats> baseTableStats, boolean explain) throws ParsingException {
- Iterator<LogicalScanNode> tableIt = tables.iterator();
- HashMap<String,String> equivMap = new HashMap<String,String>();
- HashMap<String,Double> filterSelectivities = new HashMap<String, Double>();
- HashMap<String,TableStats> statsMap = new HashMap<String,TableStats>();
-
- while (tableIt.hasNext()) {
- LogicalScanNode table = tableIt.next();
- SeqScan ss = null;
- try {
- ss = new SeqScan(t, Database.getCatalog().getDatabaseFile(table.t).getId(), table.alias);
- } catch (NoSuchElementException e) {
- throw new ParsingException("Unknown table " + table.t);
- }
-
- subplanMap.put(table.alias,ss);
- String baseTableName = Database.getCatalog().getTableName(table.t);
- statsMap.put(baseTableName, baseTableStats.get(baseTableName));
- filterSelectivities.put(table.alias, 1.0);
-
- }
-
- Iterator<LogicalFilterNode> filterIt = filters.iterator();
- while (filterIt.hasNext()) {
- LogicalFilterNode lf = filterIt.next();
- DbIterator subplan = subplanMap.get(lf.tableAlias);
- if (subplan == null) {
- throw new ParsingException("Unknown table in WHERE clause " + lf.tableAlias);
- }
-
- Field f;
- Type ftyp;
- TupleDesc td = subplanMap.get(lf.tableAlias).getTupleDesc();
-
- try {//td.fieldNameToIndex(disambiguateName(lf.fieldPureName))
- ftyp = td.getFieldType(td.fieldNameToIndex(lf.fieldQuantifiedName));
- } catch (java.util.NoSuchElementException e) {
- throw new ParsingException("Unknown field in filter expression " + lf.fieldQuantifiedName);
- }
- if (ftyp == Type.INT_TYPE)
- f = new IntField(new Integer(lf.c).intValue());
- else
- f = new StringField(lf.c, Type.STRING_LEN);
-
- Predicate p = null;
- try {
- p = new Predicate(subplan.getTupleDesc().fieldNameToIndex(lf.fieldQuantifiedName), lf.p,f);
- } catch (NoSuchElementException e) {
- throw new ParsingException("Unknown field " + lf.fieldQuantifiedName);
- }
- subplanMap.put(lf.tableAlias, new Filter(p, subplan));
-
- TableStats s = statsMap.get(Database.getCatalog().getTableName(this.getTableId(lf.tableAlias)));
-
- double sel= s.estimateSelectivity(subplan.getTupleDesc().fieldNameToIndex(lf.fieldQuantifiedName), lf.p, f);
- filterSelectivities.put(lf.tableAlias, filterSelectivities.get(lf.tableAlias) * sel);
-
- //s.addSelectivityFactor(estimateFilterSelectivity(lf,statsMap));
- }
-
- JoinOptimizer jo = new JoinOptimizer(this,joins);
-
- joins = jo.orderJoins(statsMap,filterSelectivities,explain);
-
- Iterator<LogicalJoinNode> joinIt = joins.iterator();
- while (joinIt.hasNext()) {
- LogicalJoinNode lj = joinIt.next();
- DbIterator plan1;
- DbIterator plan2;
- boolean isSubqueryJoin = lj instanceof LogicalSubplanJoinNode;
- String t1name, t2name;
-
- if (equivMap.get(lj.t1Alias)!=null)
- t1name = equivMap.get(lj.t1Alias);
- else
- t1name = lj.t1Alias;
-
- if (equivMap.get(lj.t2Alias)!=null)
- t2name = equivMap.get(lj.t2Alias);
- else
- t2name = lj.t2Alias;
-
- plan1 = subplanMap.get(t1name);
-
- if (isSubqueryJoin) {
- plan2 = ((LogicalSubplanJoinNode)lj).subPlan;
- if (plan2 == null)
- throw new ParsingException("Invalid subquery.");
- } else {
- plan2 = subplanMap.get(t2name);
- }
-
- if (plan1 == null)
- throw new ParsingException("Unknown table in WHERE clause " + lj.t1Alias);
- if (plan2 == null)
- throw new ParsingException("Unknown table in WHERE clause " + lj.t2Alias);
-
- DbIterator j;
- j = jo.instantiateJoin(lj,plan1,plan2);
- subplanMap.put(t1name, j);
-
- if (!isSubqueryJoin) {
- subplanMap.remove(t2name);
- equivMap.put(t2name,t1name); //keep track of the fact that this new node contains both tables
- //make sure anything that was equiv to lj.t2 (which we are just removed) is
- // marked as equiv to lj.t1 (which we are replacing lj.t2 with.)
- for (java.util.Map.Entry<String, String> s: equivMap.entrySet()) {
- String val = s.getValue();
- if (val.equals(t2name)) {
- s.setValue(t1name);
- }
- }
-
- // subplanMap.put(lj.t2, j);
- }
-
- }
-
- if (subplanMap.size() > 1) {
- throw new ParsingException("Query does not include join expressions joining all nodes!");
- }
-
- DbIterator node = (DbIterator)(subplanMap.entrySet().iterator().next().getValue());
-
- //walk the select list, to determine order in which to project output fields
- ArrayList<Integer> outFields = new ArrayList<Integer>();
- ArrayList<Type> outTypes = new ArrayList<Type>();
- for (int i = 0; i < selectList.size(); i++) {
- LogicalSelectListNode si = selectList.elementAt(i);
- if (si.aggOp != null) {
- outFields.add(groupByField!=null?1:0);
- TupleDesc td = node.getTupleDesc();
-// int id;
- try {
-// id =
- td.fieldNameToIndex(si.fname);
- } catch (NoSuchElementException e) {
- throw new ParsingException("Unknown field " + si.fname + " in SELECT list");
- }
- outTypes.add(Type.INT_TYPE); //the type of all aggregate functions is INT
-
- } else if (hasAgg) {
- if (groupByField == null) {
- throw new ParsingException("Field " + si.fname + " does not appear in GROUP BY list");
- }
- outFields.add(0);
- TupleDesc td = node.getTupleDesc();
- int id;
- try {
- id = td.fieldNameToIndex(groupByField);
- } catch (NoSuchElementException e) {
- throw new ParsingException("Unknown field " + groupByField + " in GROUP BY statement");
- }
- outTypes.add(td.getFieldType(id));
- } else if (si.fname.equals("null.*")) {
- TupleDesc td = node.getTupleDesc();
- for ( i = 0; i < td.numFields(); i++) {
- outFields.add(i);
- outTypes.add(td.getFieldType(i));
- }
- } else {
- TupleDesc td = node.getTupleDesc();
- int id;
- try {
- id = td.fieldNameToIndex(si.fname);
- } catch (NoSuchElementException e) {
- throw new ParsingException("Unknown field " + si.fname + " in SELECT list");
- }
- outFields.add(id);
- outTypes.add(td.getFieldType(id));
-
- }
- }
-
- if (hasAgg) {
- TupleDesc td = node.getTupleDesc();
- Aggregate aggNode;
- try {
- aggNode = new Aggregate(node,
- td.fieldNameToIndex(aggField),
- groupByField == null?Aggregator.NO_GROUPING:td.fieldNameToIndex(groupByField),
- getAggOp(aggOp));
- } catch (NoSuchElementException e) {
- throw new simpledb.ParsingException(e);
- } catch (IllegalArgumentException e) {
- throw new simpledb.ParsingException(e);
- }
- node = aggNode;
- }
-
- if (hasOrderBy) {
- node = new OrderBy(node.getTupleDesc().fieldNameToIndex(oByField), oByAsc, node);
- }
-
- return new Project(outFields, outTypes, node);
- }
-
- public static void main(String argv[]) {
- // construct a 3-column table schema
- Type types[] = new Type[]{ Type.INT_TYPE, Type.INT_TYPE, Type.INT_TYPE };
- String names[] = new String[]{ "field0", "field1", "field2" };
-
- TupleDesc td = new TupleDesc(types, names);
- TableStats ts;
- HashMap<String, TableStats> tableMap = new HashMap<String,TableStats>();
-
- // create the tables, associate them with the data files
- // and tell the catalog about the schema the tables.
- HeapFile table1 = new HeapFile(new File("some_data_file1.dat"), td);
- Database.getCatalog().addTable(table1, "t1");
- ts = new TableStats(table1.getId(), 1);
- tableMap.put("t1", ts);
-
- TransactionId tid = new TransactionId();
-
- LogicalPlan lp = new LogicalPlan();
-
- lp.addScan(table1.getId(), "t1");
-
- try {
- lp.addFilter("t1.field0", Predicate.Op.GREATER_THAN, "1");
- } catch (Exception e) {
- }
-
- /*
- SeqScan ss1 = new SeqScan(tid, table1.getId(), "t1");
- SeqScan ss2 = new SeqScan(tid, table2.getId(), "t2");
-
- // create a filter for the where condition
- Filter sf1 = new Filter(
- new Predicate(0,
- Predicate.Op.GREATER_THAN, new IntField(1)), ss1);
-
- JoinPredicate p = new JoinPredicate(1, Predicate.Op.EQUALS, 1);
- Join j = new Join(p, sf1, ss2);
- */
- DbIterator j = null;
- try {
- j = lp.physicalPlan(tid,tableMap, false);
- } catch (ParsingException e) {
- e.printStackTrace();
- System.exit(0);
- }
- // and run it
- try {
- j.open();
- while (j.hasNext()) {
- Tuple tup = j.next();
- System.out.println(tup);
- }
- j.close();
- Database.getBufferPool().transactionComplete(tid);
-
- } catch (Exception e) {
- e.printStackTrace();
- }
-
- }
-
-}
\ No newline at end of file
diff --git a/hw/hw3/starter-code/src/java/simpledb/LogicalScanNode.java b/hw/hw3/starter-code/src/java/simpledb/LogicalScanNode.java
deleted file mode 100644
index 476a25d82df93a08840b21bf452c55408ff24259..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/LogicalScanNode.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package simpledb;
-
-/** A LogicalScanNode represents table in the FROM list in a
- * LogicalQueryPlan */
-public class LogicalScanNode {
-
- /** The name (alias) of the table as it is used in the query */
- public String alias;
-
- /** The table identifier (can be passed to {@link Catalog#getDatabaseFile})
- * to retrieve a DbFile */
- public int t;
-
- public LogicalScanNode(int table, String tableAlias) {
- this.alias = tableAlias;
- this.t = table;
- }
-}
-
diff --git a/hw/hw3/starter-code/src/java/simpledb/LogicalSelectListNode.java b/hw/hw3/starter-code/src/java/simpledb/LogicalSelectListNode.java
deleted file mode 100644
index c32e718e1bfaea53419da3fdf85ac74e4ee2b1e5..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/LogicalSelectListNode.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package simpledb;
-
-/** A LogicalSelectListNode represents a clause in the select list in
- * a LogicalQueryPlan
-*/
-public class LogicalSelectListNode {
- /** The field name being selected; the name may be (optionally) be
- * qualified with a table name or alias.
- */
- public String fname;
-
- /** The aggregation operation over the field (if any) */
- public String aggOp;
-
- public LogicalSelectListNode(String aggOp, String fname) {
- this.aggOp = aggOp;
- this.fname = fname;
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/LogicalSubplanJoinNode.java b/hw/hw3/starter-code/src/java/simpledb/LogicalSubplanJoinNode.java
deleted file mode 100644
index be7f803fd74ffc3b0c2fa86ba5e0ee6be51a4711..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/LogicalSubplanJoinNode.java
+++ /dev/null
@@ -1,41 +0,0 @@
-package simpledb;
-
-/** A LogicalSubplanJoinNode represens the state needed of a join of a
- * table to a subplan in a LogicalQueryPlan -- inherits state from
- * {@link LogicalJoinNode}; t2 and f2 should always be null
- */
-public class LogicalSubplanJoinNode extends LogicalJoinNode {
-
- /** The subplan (used on the inner) of the join */
- DbIterator subPlan;
-
- public LogicalSubplanJoinNode(String table1, String joinField1, DbIterator sp, Predicate.Op pred) {
- t1Alias = table1;
- String[] tmps = joinField1.split("[.]");
- if (tmps.length>1)
- f1PureName = tmps[tmps.length-1];
- else
- f1PureName=joinField1;
- f1QuantifiedName=t1Alias+"."+f1PureName;
- subPlan = sp;
- p = pred;
- }
-
- @Override public int hashCode() {
- return t1Alias.hashCode() + f1PureName.hashCode() + subPlan.hashCode();
- }
-
- @Override public boolean equals(Object o) {
- LogicalJoinNode j2 =(LogicalJoinNode)o;
- if (!(o instanceof LogicalSubplanJoinNode))
- return false;
-
- return (j2.t1Alias.equals(t1Alias) && j2.f1PureName.equals(f1PureName) && ((LogicalSubplanJoinNode)o).subPlan.equals(subPlan));
- }
-
- public LogicalSubplanJoinNode swapInnerOuter() {
- LogicalSubplanJoinNode j2 = new LogicalSubplanJoinNode(t1Alias,f1PureName,subPlan, p);
- return j2;
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Operator.java b/hw/hw3/starter-code/src/java/simpledb/Operator.java
deleted file mode 100644
index 356107811a2852b91c1e81e63ef279bb1a501d24..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Operator.java
+++ /dev/null
@@ -1,107 +0,0 @@
-package simpledb;
-
-import java.util.NoSuchElementException;
-
-/**
- * Abstract class for implementing operators. It handles <code>close</code>,
- * <code>next</code> and <code>hasNext</code>. Subclasses only need to implement
- * <code>open</code> and <code>readNext</code>.
- */
-public abstract class Operator implements DbIterator {
-
- private static final long serialVersionUID = 1L;
-
- public boolean hasNext() throws DbException, TransactionAbortedException {
- if (!this.open)
- throw new IllegalStateException("Operator not yet open");
-
- if (next == null)
- next = fetchNext();
- return next != null;
- }
-
- public Tuple next() throws DbException, TransactionAbortedException,
- NoSuchElementException {
- if (next == null) {
- next = fetchNext();
- if (next == null)
- throw new NoSuchElementException();
- }
-
- Tuple result = next;
- next = null;
- return result;
- }
-
- /**
- * Returns the next Tuple in the iterator, or null if the iteration is
- * finished. Operator uses this method to implement both <code>next</code>
- * and <code>hasNext</code>.
- *
- * @return the next Tuple in the iterator, or null if the iteration is
- * finished.
- */
- protected abstract Tuple fetchNext() throws DbException,
- TransactionAbortedException;
-
- /**
- * Closes this iterator. If overridden by a subclass, they should call
- * super.close() in order for Operator's internal state to be consistent.
- */
- public void close() {
- // Ensures that a future call to next() will fail
- next = null;
- this.open = false;
- }
-
- private Tuple next = null;
- private boolean open = false;
- private int estimatedCardinality = 0;
-
- public void open() throws DbException, TransactionAbortedException {
- this.open = true;
- }
-
- /**
- * @return return the children DbIterators of this operator. If there is
- * only one child, return an array of only one element. For join
- * operators, the order of the children is not important. But they
- * should be consistent among multiple calls.
- * */
- public abstract DbIterator[] getChildren();
-
- /**
- * Set the children(child) of this operator. If the operator has only one
- * child, children[0] should be used. If the operator is a join, children[0]
- * and children[1] should be used.
- *
- *
- * @param children
- * the DbIterators which are to be set as the children(child) of
- * this operator
- * */
- public abstract void setChildren(DbIterator[] children);
-
- /**
- * @return return the TupleDesc of the output tuples of this operator
- * */
- public abstract TupleDesc getTupleDesc();
-
- /**
- * @return The estimated cardinality of this operator. Will only be used in
- * lab6
- * */
- public int getEstimatedCardinality() {
- return this.estimatedCardinality;
- }
-
- /**
- * @param card
- * The estimated cardinality of this operator Will only be used
- * in lab6
- * */
- protected void setEstimatedCardinality(int card) {
- this.estimatedCardinality = card;
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/OrderBy.java b/hw/hw3/starter-code/src/java/simpledb/OrderBy.java
deleted file mode 100644
index 0874c152950d1da66477ccf73ebae74cb74b8310..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/OrderBy.java
+++ /dev/null
@@ -1,123 +0,0 @@
-package simpledb;
-
-import java.util.*;
-
-/**
- * OrderBy is an operator that implements a relational ORDER BY.
- */
-public class OrderBy extends Operator {
-
- private static final long serialVersionUID = 1L;
- private DbIterator child;
- private TupleDesc td;
- private ArrayList<Tuple> childTups = new ArrayList<Tuple>();
- private int orderByField;
- private String orderByFieldName;
- private Iterator<Tuple> it;
- private boolean asc;
-
- /**
- * Creates a new OrderBy node over the tuples from the iterator.
- *
- * @param orderbyField
- * the field to which the sort is applied.
- * @param asc
- * true if the sort order is ascending.
- * @param child
- * the tuples to sort.
- */
- public OrderBy(int orderbyField, boolean asc, DbIterator child) {
- this.child = child;
- td = child.getTupleDesc();
- this.orderByField = orderbyField;
- this.orderByFieldName = td.getFieldName(orderbyField);
- this.asc = asc;
- }
-
- public boolean isASC()
- {
- return this.asc;
- }
-
- public int getOrderByField()
- {
- return this.orderByField;
- }
-
- public String getOrderFieldName()
- {
- return this.orderByFieldName;
- }
-
- public TupleDesc getTupleDesc() {
- return td;
- }
-
- public void open() throws DbException, NoSuchElementException,
- TransactionAbortedException {
- child.open();
- // load all the tuples in a collection, and sort it
- while (child.hasNext())
- childTups.add((Tuple) child.next());
- Collections.sort(childTups, new TupleComparator(orderByField, asc));
- it = childTups.iterator();
- super.open();
- }
-
- public void close() {
- super.close();
- it = null;
- }
-
- public void rewind() throws DbException, TransactionAbortedException {
- it = childTups.iterator();
- }
-
- /**
- * Operator.fetchNext implementation. Returns tuples from the child operator
- * in order
- *
- * @return The next tuple in the ordering, or null if there are no more
- * tuples
- */
- protected Tuple fetchNext() throws NoSuchElementException,
- TransactionAbortedException, DbException {
- if (it != null && it.hasNext()) {
- return it.next();
- } else
- return null;
- }
-
- @Override
- public DbIterator[] getChildren() {
- return new DbIterator[] { this.child };
- }
-
- @Override
- public void setChildren(DbIterator[] children) {
- this.child = children[0];
- }
-
-}
-
-class TupleComparator implements Comparator<Tuple> {
- int field;
- boolean asc;
-
- public TupleComparator(int field, boolean asc) {
- this.field = field;
- this.asc = asc;
- }
-
- public int compare(Tuple o1, Tuple o2) {
- Field t1 = (o1).getField(field);
- Field t2 = (o2).getField(field);
- if (t1.compare(Predicate.Op.EQUALS, t2))
- return 0;
- if (t1.compare(Predicate.Op.GREATER_THAN, t2))
- return asc ? 1 : -1;
- else
- return asc ? -1 : 1;
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Page.java b/hw/hw3/starter-code/src/java/simpledb/Page.java
deleted file mode 100644
index 1f7ab022db7424f853f0ba41ef710b56408bace7..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Page.java
+++ /dev/null
@@ -1,59 +0,0 @@
-package simpledb;
-
-/**
- * Page is the interface used to represent pages that are resident in the
- * BufferPool. Typically, DbFiles will read and write pages from disk.
- * <p>
- * Pages may be "dirty", indicating that they have been modified since they
- * were last written out to disk.
- *
- * For recovery purposes, pages MUST have a single constructor of the form:
- * Page(PageId id, byte[] data)
- */
-public interface Page {
-
- /**
- * Return the id of this page. The id is a unique identifier for a page
- * that can be used to look up the page on disk or determine if the page
- * is resident in the buffer pool.
- *
- * @return the id of this page
- */
- public PageId getId();
-
- /**
- * Get the id of the transaction that last dirtied this page, or null if the page is clean..
- *
- * @return The id of the transaction that last dirtied this page, or null
- */
- public TransactionId isDirty();
-
- /**
- * Set the dirty state of this page as dirtied by a particular transaction
- */
- public void markDirty(boolean dirty, TransactionId tid);
-
- /**
- * Generates a byte array representing the contents of this page.
- * Used to serialize this page to disk.
- * <p>
- * The invariant here is that it should be possible to pass the byte array
- * generated by getPageData to the Page constructor and have it produce
- * an identical Page object.
- *
- * @return A byte array correspond to the bytes of this page.
- */
-
- public byte[] getPageData();
-
- /** Provide a representation of this page before any modifications were made
- to it. Used by recovery.
- */
- public Page getBeforeImage();
-
- /*
- * a transaction that wrote this page just committed it.
- * copy current content to the before image.
- */
- public void setBeforeImage();
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/PageId.java b/hw/hw3/starter-code/src/java/simpledb/PageId.java
deleted file mode 100644
index 679ffaacf1b1b6a2c089b82058d34c065dcb33d0..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/PageId.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package simpledb;
-
-/** PageId is an interface to a specific page of a specific table. */
-public interface PageId {
-
- /** Return a representation of this page id object as a collection of
- integers (used for logging)
-
- This class MUST have a constructor that accepts n integer parameters,
- where n is the number of integers returned in the array from serialize.
- */
- public int[] serialize();
-
- /** @return the unique tableid hashcode with this PageId */
- public int getTableId();
-
- /**
- * @return a hash code for this page, represented by the concatenation of
- * the table number and the page number (needed if a PageId is used as a
- * key in a hash table in the BufferPool, for example.)
- * @see BufferPool
- */
- public int hashCode();
-
- /**
- * Compares one PageId to another.
- *
- * @param o The object to compare against (must be a PageId)
- * @return true if the objects are equal (e.g., page numbers and table
- * ids are the same)
- */
- public boolean equals(Object o);
-
- public int pageNumber();
-}
-
diff --git a/hw/hw3/starter-code/src/java/simpledb/Parser.java b/hw/hw3/starter-code/src/java/simpledb/Parser.java
deleted file mode 100644
index e372f7598d6ab04b8bf9f090dc3d7facba88abac..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Parser.java
+++ /dev/null
@@ -1,754 +0,0 @@
-package simpledb;
-
-import Zql.*;
-import java.io.*;
-import java.lang.reflect.InvocationTargetException;
-import java.util.*;
-
-import jline.ArgumentCompletor;
-import jline.ConsoleReader;
-import jline.SimpleCompletor;
-
-public class Parser {
- static boolean explain = false;
-
- public static Predicate.Op getOp(String s) throws simpledb.ParsingException {
- if (s.equals("="))
- return Predicate.Op.EQUALS;
- if (s.equals(">"))
- return Predicate.Op.GREATER_THAN;
- if (s.equals(">="))
- return Predicate.Op.GREATER_THAN_OR_EQ;
- if (s.equals("<"))
- return Predicate.Op.LESS_THAN;
- if (s.equals("<="))
- return Predicate.Op.LESS_THAN_OR_EQ;
- if (s.equals("LIKE"))
- return Predicate.Op.LIKE;
- if (s.equals("~"))
- return Predicate.Op.LIKE;
- if (s.equals("<>"))
- return Predicate.Op.NOT_EQUALS;
- if (s.equals("!="))
- return Predicate.Op.NOT_EQUALS;
-
- throw new simpledb.ParsingException("Unknown predicate " + s);
- }
-
- void processExpression(TransactionId tid, ZExpression wx, LogicalPlan lp)
- throws simpledb.ParsingException {
- if (wx.getOperator().equals("AND")) {
- for (int i = 0; i < wx.nbOperands(); i++) {
- if (!(wx.getOperand(i) instanceof ZExpression)) {
- throw new simpledb.ParsingException(
- "Nested queries are currently unsupported.");
- }
- ZExpression newWx = (ZExpression) wx.getOperand(i);
- processExpression(tid, newWx, lp);
-
- }
- } else if (wx.getOperator().equals("OR")) {
- throw new simpledb.ParsingException(
- "OR expressions currently unsupported.");
- } else {
- // this is a binary expression comparing two constants
- @SuppressWarnings("unchecked")
- Vector<ZExp> ops = wx.getOperands();
- if (ops.size() != 2) {
- throw new simpledb.ParsingException(
- "Only simple binary expresssions of the form A op B are currently supported.");
- }
-
- boolean isJoin = false;
- Predicate.Op op = getOp(wx.getOperator());
-
- boolean op1const = ops.elementAt(0) instanceof ZConstant; // otherwise
- // is a
- // Query
- boolean op2const = ops.elementAt(1) instanceof ZConstant; // otherwise
- // is a
- // Query
- if (op1const && op2const) {
- isJoin = ((ZConstant) ops.elementAt(0)).getType() == ZConstant.COLUMNNAME
- && ((ZConstant) ops.elementAt(1)).getType() == ZConstant.COLUMNNAME;
- } else if (ops.elementAt(0) instanceof ZQuery
- || ops.elementAt(1) instanceof ZQuery) {
- isJoin = true;
- } else if (ops.elementAt(0) instanceof ZExpression
- || ops.elementAt(1) instanceof ZExpression) {
- throw new simpledb.ParsingException(
- "Only simple binary expresssions of the form A op B are currently supported, where A or B are fields, constants, or subqueries.");
- } else
- isJoin = false;
-
- if (isJoin) { // join node
-
- String tab1field = "", tab2field = "";
-
- if (!op1const) { // left op is a nested query
- // generate a virtual table for the left op
- // this isn't a valid ZQL query
- } else {
- tab1field = ((ZConstant) ops.elementAt(0)).getValue();
-
- }
-
- if (!op2const) { // right op is a nested query
- try {
- LogicalPlan sublp = parseQueryLogicalPlan(tid,
- (ZQuery) ops.elementAt(1));
- DbIterator pp = sublp.physicalPlan(tid,
- TableStats.getStatsMap(), explain);
- lp.addJoin(tab1field, pp, op);
- } catch (IOException e) {
- throw new simpledb.ParsingException("Invalid subquery "
- + ops.elementAt(1));
- } catch (Zql.ParseException e) {
- throw new simpledb.ParsingException("Invalid subquery "
- + ops.elementAt(1));
- }
- } else {
- tab2field = ((ZConstant) ops.elementAt(1)).getValue();
- lp.addJoin(tab1field, tab2field, op);
- }
-
- } else { // select node
- String column;
- String compValue;
- ZConstant op1 = (ZConstant) ops.elementAt(0);
- ZConstant op2 = (ZConstant) ops.elementAt(1);
- if (op1.getType() == ZConstant.COLUMNNAME) {
- column = op1.getValue();
- compValue = new String(op2.getValue());
- } else {
- column = op2.getValue();
- compValue = new String(op1.getValue());
- }
-
- lp.addFilter(column, op, compValue);
-
- }
- }
-
- }
-
- public LogicalPlan parseQueryLogicalPlan(TransactionId tid, ZQuery q)
- throws IOException, Zql.ParseException, simpledb.ParsingException {
- @SuppressWarnings("unchecked")
- Vector<ZFromItem> from = q.getFrom();
- LogicalPlan lp = new LogicalPlan();
- lp.setQuery(q.toString());
- // walk through tables in the FROM clause
- for (int i = 0; i < from.size(); i++) {
- ZFromItem fromIt = from.elementAt(i);
- try {
-
- int id = Database.getCatalog().getTableId(fromIt.getTable()); // will
- // fall
- // through
- // if
- // table
- // doesn't
- // exist
- String name;
-
- if (fromIt.getAlias() != null)
- name = fromIt.getAlias();
- else
- name = fromIt.getTable();
-
- lp.addScan(id, name);
-
- // XXX handle subquery?
- } catch (NoSuchElementException e) {
- e.printStackTrace();
- throw new simpledb.ParsingException("Table "
- + fromIt.getTable() + " is not in catalog");
- }
- }
-
- // now parse the where clause, creating Filter and Join nodes as needed
- ZExp w = q.getWhere();
- if (w != null) {
-
- if (!(w instanceof ZExpression)) {
- throw new simpledb.ParsingException(
- "Nested queries are currently unsupported.");
- }
- ZExpression wx = (ZExpression) w;
- processExpression(tid, wx, lp);
-
- }
-
- // now look for group by fields
- ZGroupBy gby = q.getGroupBy();
- String groupByField = null;
- if (gby != null) {
- @SuppressWarnings("unchecked")
- Vector<ZExp> gbs = gby.getGroupBy();
- if (gbs.size() > 1) {
- throw new simpledb.ParsingException(
- "At most one grouping field expression supported.");
- }
- if (gbs.size() == 1) {
- ZExp gbe = gbs.elementAt(0);
- if (!(gbe instanceof ZConstant)) {
- throw new simpledb.ParsingException(
- "Complex grouping expressions (" + gbe
- + ") not supported.");
- }
- groupByField = ((ZConstant) gbe).getValue();
- System.out.println("GROUP BY FIELD : " + groupByField);
- }
-
- }
-
- // walk the select list, pick out aggregates, and check for query
- // validity
- @SuppressWarnings("unchecked")
- Vector<ZSelectItem> selectList = q.getSelect();
- String aggField = null;
- String aggFun = null;
-
- for (int i = 0; i < selectList.size(); i++) {
- ZSelectItem si = selectList.elementAt(i);
- if (si.getAggregate() == null
- && (si.isExpression() && !(si.getExpression() instanceof ZConstant))) {
- throw new simpledb.ParsingException(
- "Expressions in SELECT list are not supported.");
- }
- if (si.getAggregate() != null) {
- if (aggField != null) {
- throw new simpledb.ParsingException(
- "Aggregates over multiple fields not supported.");
- }
- aggField = ((ZConstant) ((ZExpression) si.getExpression())
- .getOperand(0)).getValue();
- aggFun = si.getAggregate();
- System.out.println("Aggregate field is " + aggField
- + ", agg fun is : " + aggFun);
- lp.addProjectField(aggField, aggFun);
- } else {
- if (groupByField != null
- && !(groupByField.equals(si.getTable() + "."
- + si.getColumn()) || groupByField.equals(si
- .getColumn()))) {
- throw new simpledb.ParsingException("Non-aggregate field "
- + si.getColumn()
- + " does not appear in GROUP BY list.");
- }
- lp.addProjectField(si.getTable() + "." + si.getColumn(), null);
- }
- }
-
- if (groupByField != null && aggFun == null) {
- throw new simpledb.ParsingException("GROUP BY without aggregation.");
- }
-
- if (aggFun != null) {
- lp.addAggregate(aggFun, aggField, groupByField);
- }
- // sort the data
-
- if (q.getOrderBy() != null) {
- @SuppressWarnings("unchecked")
- Vector<ZOrderBy> obys = q.getOrderBy();
- if (obys.size() > 1) {
- throw new simpledb.ParsingException(
- "Multi-attribute ORDER BY is not supported.");
- }
- ZOrderBy oby = obys.elementAt(0);
- if (!(oby.getExpression() instanceof ZConstant)) {
- throw new simpledb.ParsingException(
- "Complex ORDER BY's are not supported");
- }
- ZConstant f = (ZConstant) oby.getExpression();
-
- lp.addOrderBy(f.getValue(), oby.getAscOrder());
-
- }
- return lp;
- }
-
- private Transaction curtrans = null;
- private boolean inUserTrans = false;
-
- public Query handleQueryStatement(ZQuery s, TransactionId tId)
- throws TransactionAbortedException, DbException, IOException,
- simpledb.ParsingException, Zql.ParseException {
- Query query = new Query(tId);
-
- LogicalPlan lp = parseQueryLogicalPlan(tId, s);
- DbIterator physicalPlan = lp.physicalPlan(tId,
- TableStats.getStatsMap(), explain);
- query.setPhysicalPlan(physicalPlan);
- query.setLogicalPlan(lp);
-
- if (physicalPlan != null) {
- Class<?> c;
- try {
- c = Class.forName("simpledb.OperatorCardinality");
-
- Class<?> p = Operator.class;
- Class<?> h = Map.class;
-
- java.lang.reflect.Method m = c.getMethod(
- "updateOperatorCardinality", p, h, h);
-
- System.out.println("The query plan is:");
- m.invoke(null, (Operator) physicalPlan,
- lp.getTableAliasToIdMapping(), TableStats.getStatsMap());
- c = Class.forName("simpledb.QueryPlanVisualizer");
- m = c.getMethod(
- "printQueryPlanTree", DbIterator.class, System.out.getClass());
- m.invoke(c.newInstance(), physicalPlan,System.out);
- } catch (ClassNotFoundException e) {
- } catch (SecurityException e) {
- } catch (NoSuchMethodException e) {
- e.printStackTrace();
- } catch (IllegalArgumentException e) {
- e.printStackTrace();
- } catch (IllegalAccessException e) {
- e.printStackTrace();
- } catch (InvocationTargetException e) {
- e.printStackTrace();
- } catch (InstantiationException e) {
- e.printStackTrace();
- }
- }
-
- return query;
- }
-
- public Query handleInsertStatement(ZInsert s, TransactionId tId)
- throws TransactionAbortedException, DbException, IOException,
- simpledb.ParsingException, Zql.ParseException {
- int tableId;
- try {
- tableId = Database.getCatalog().getTableId(s.getTable()); // will
- // fall
- // through if
- // table
- // doesn't
- // exist
- } catch (NoSuchElementException e) {
- throw new simpledb.ParsingException("Unknown table : "
- + s.getTable());
- }
-
- TupleDesc td = Database.getCatalog().getTupleDesc(tableId);
-
- Tuple t = new Tuple(td);
- int i = 0;
- DbIterator newTups;
-
- if (s.getValues() != null) {
- @SuppressWarnings("unchecked")
- Vector<ZExp> values = (Vector<ZExp>) s.getValues();
- if (td.numFields() != values.size()) {
- throw new simpledb.ParsingException(
- "INSERT statement does not contain same number of fields as table "
- + s.getTable());
- }
- for (ZExp e : values) {
-
- if (!(e instanceof ZConstant))
- throw new simpledb.ParsingException(
- "Complex expressions not allowed in INSERT statements.");
- ZConstant zc = (ZConstant) e;
- if (zc.getType() == ZConstant.NUMBER) {
- if (td.getFieldType(i) != Type.INT_TYPE) {
- throw new simpledb.ParsingException("Value "
- + zc.getValue()
- + " is not an integer, expected a string.");
- }
- IntField f = new IntField(new Integer(zc.getValue()));
- t.setField(i, f);
- } else if (zc.getType() == ZConstant.STRING) {
- if (td.getFieldType(i) != Type.STRING_TYPE) {
- throw new simpledb.ParsingException("Value "
- + zc.getValue()
- + " is a string, expected an integer.");
- }
- StringField f = new StringField(zc.getValue(),
- Type.STRING_LEN);
- t.setField(i, f);
- } else {
- throw new simpledb.ParsingException(
- "Only string or int fields are supported.");
- }
-
- i++;
- }
- ArrayList<Tuple> tups = new ArrayList<Tuple>();
- tups.add(t);
- newTups = new TupleArrayIterator(tups);
-
- } else {
- ZQuery zq = (ZQuery) s.getQuery();
- LogicalPlan lp = parseQueryLogicalPlan(tId, zq);
- newTups = lp.physicalPlan(tId, TableStats.getStatsMap(), explain);
- }
- Query insertQ = new Query(tId);
- insertQ.setPhysicalPlan(new Insert(tId, newTups, tableId));
- return insertQ;
- }
-
- public Query handleDeleteStatement(ZDelete s, TransactionId tid)
- throws TransactionAbortedException, DbException, IOException,
- simpledb.ParsingException, Zql.ParseException {
- int id;
- try {
- id = Database.getCatalog().getTableId(s.getTable()); // will fall
- // through if
- // table
- // doesn't
- // exist
- } catch (NoSuchElementException e) {
- throw new simpledb.ParsingException("Unknown table : "
- + s.getTable());
- }
- String name = s.getTable();
- Query sdbq = new Query(tid);
-
- LogicalPlan lp = new LogicalPlan();
- lp.setQuery(s.toString());
-
- lp.addScan(id, name);
- if (s.getWhere() != null)
- processExpression(tid, (ZExpression) s.getWhere(), lp);
- lp.addProjectField("null.*", null);
-
- DbIterator op = new Delete(tid, lp.physicalPlan(tid,
- TableStats.getStatsMap(), false));
- sdbq.setPhysicalPlan(op);
-
- return sdbq;
-
- }
-
- public void handleTransactStatement(ZTransactStmt s)
- throws TransactionAbortedException, DbException, IOException,
- simpledb.ParsingException, Zql.ParseException {
- if (s.getStmtType().equals("COMMIT")) {
- if (curtrans == null)
- throw new simpledb.ParsingException(
- "No transaction is currently running");
- curtrans.commit();
- curtrans = null;
- inUserTrans = false;
- System.out.println("Transaction " + curtrans.getId().getId()
- + " committed.");
- } else if (s.getStmtType().equals("ROLLBACK")) {
- if (curtrans == null)
- throw new simpledb.ParsingException(
- "No transaction is currently running");
- curtrans.abort();
- curtrans = null;
- inUserTrans = false;
- System.out.println("Transaction " + curtrans.getId().getId()
- + " aborted.");
-
- } else if (s.getStmtType().equals("SET TRANSACTION")) {
- if (curtrans != null)
- throw new simpledb.ParsingException(
- "Can't start new transactions until current transaction has been committed or rolledback.");
- curtrans = new Transaction();
- curtrans.start();
- inUserTrans = true;
- System.out.println("Started a new transaction tid = "
- + curtrans.getId().getId());
- } else {
- throw new simpledb.ParsingException("Unsupported operation");
- }
- }
-
- public LogicalPlan generateLogicalPlan(TransactionId tid, String s)
- throws simpledb.ParsingException {
- ByteArrayInputStream bis = new ByteArrayInputStream(s.getBytes());
- ZqlParser p = new ZqlParser(bis);
- try {
- ZStatement stmt = p.readStatement();
- if (stmt instanceof ZQuery) {
- LogicalPlan lp = parseQueryLogicalPlan(tid, (ZQuery) stmt);
- return lp;
- }
- } catch (Zql.ParseException e) {
- throw new simpledb.ParsingException(
- "Invalid SQL expression: \n \t " + e);
- } catch (IOException e) {
- throw new simpledb.ParsingException(e);
- }
-
- throw new simpledb.ParsingException(
- "Cannot generate logical plan for expression : " + s);
- }
-
- public void setTransaction(Transaction t) {
- curtrans = t;
- }
-
- public Transaction getTransaction() {
- return curtrans;
- }
-
- public void processNextStatement(String s) {
- try {
- processNextStatement(new ByteArrayInputStream(s.getBytes("UTF-8")));
- } catch (UnsupportedEncodingException e) {
- e.printStackTrace();
- throw new RuntimeException(e);
- }
- }
-
- public void processNextStatement(InputStream is) {
- try {
- ZqlParser p = new ZqlParser(is);
- ZStatement s = p.readStatement();
-
- Query query = null;
- if (s instanceof ZTransactStmt)
- handleTransactStatement((ZTransactStmt) s);
- else {
- if (!this.inUserTrans) {
- curtrans = new Transaction();
- curtrans.start();
- System.out.println("Started a new transaction tid = "
- + curtrans.getId().getId());
- }
- try {
- if (s instanceof ZInsert)
- query = handleInsertStatement((ZInsert) s,
- curtrans.getId());
- else if (s instanceof ZDelete)
- query = handleDeleteStatement((ZDelete) s,
- curtrans.getId());
- else if (s instanceof ZQuery)
- query = handleQueryStatement((ZQuery) s,
- curtrans.getId());
- else {
- System.out
- .println("Can't parse "
- + s
- + "\n -- parser only handles SQL transactions, insert, delete, and select statements");
- }
- if (query != null)
- query.execute();
-
- if (!inUserTrans && curtrans != null) {
- curtrans.commit();
- System.out.println("Transaction "
- + curtrans.getId().getId() + " committed.");
- }
- } catch (Throwable a) {
- // Whenever error happens, abort the current transaction
- if (curtrans != null) {
- curtrans.abort();
- System.out.println("Transaction "
- + curtrans.getId().getId()
- + " aborted because of unhandled error");
- }
- this.inUserTrans = false;
-
- if (a instanceof simpledb.ParsingException
- || a instanceof Zql.ParseException)
- throw new ParsingException((Exception) a);
- if (a instanceof Zql.TokenMgrError)
- throw (Zql.TokenMgrError) a;
- throw new DbException(a.getMessage());
- } finally {
- if (!inUserTrans)
- curtrans = null;
- }
- }
-
- } catch (TransactionAbortedException e) {
- e.printStackTrace();
- } catch (DbException e) {
- e.printStackTrace();
- } catch (IOException e) {
- e.printStackTrace();
- } catch (simpledb.ParsingException e) {
- System.out
- .println("Invalid SQL expression: \n \t" + e.getMessage());
- } catch (Zql.ParseException e) {
- System.out.println("Invalid SQL expression: \n \t " + e);
- } catch (Zql.TokenMgrError e) {
- System.out.println("Invalid SQL expression: \n \t " + e);
- }
- }
-
- // Basic SQL completions
- public static final String[] SQL_COMMANDS = { "select", "from", "where",
- "group by", "max(", "min(", "avg(", "count", "rollback", "commit",
- "insert", "delete", "values", "into" };
-
- public static void main(String argv[]) throws IOException {
-
- if (argv.length < 1 || argv.length > 4) {
- System.out.println("Invalid number of arguments.\n" + usage);
- System.exit(0);
- }
-
- Parser p = new Parser();
-
- p.start(argv);
- }
-
- static final String usage = "Usage: parser catalogFile [-explain] [-f queryFile]";
-
- protected void shutdown() {
- System.out.println("Bye");
- }
-
- protected boolean interactive = true;
-
- protected void start(String[] argv) throws IOException {
- // first add tables to database
- Database.getCatalog().loadSchema(argv[0]);
- TableStats.computeStatistics();
-
- String queryFile = null;
-
- if (argv.length > 1) {
- for (int i = 1; i < argv.length; i++) {
- if (argv[i].equals("-explain")) {
- explain = true;
- System.out.println("Explain mode enabled.");
- } else if (argv[i].equals("-f")) {
- interactive = false;
- if (i++ == argv.length) {
- System.out.println("Expected file name after -f\n"
- + usage);
- System.exit(0);
- }
- queryFile = argv[i];
-
- } else {
- System.out.println("Unknown argument " + argv[i] + "\n "
- + usage);
- }
- }
- }
- if (!interactive) {
- try {
- // curtrans = new Transaction();
- // curtrans.start();
- long startTime = System.currentTimeMillis();
- processNextStatement(new FileInputStream(new File(queryFile)));
- long time = System.currentTimeMillis() - startTime;
- System.out.printf("----------------\n%.2f seconds\n\n",
- ((double) time / 1000.0));
- System.out.println("Press Enter to exit");
- System.in.read();
- this.shutdown();
- } catch (FileNotFoundException e) {
- System.out.println("Unable to find query file" + queryFile);
- e.printStackTrace();
- }
- } else { // no query file, run interactive prompt
- ConsoleReader reader = new ConsoleReader();
-
- // Add really stupid tab completion for simple SQL
- ArgumentCompletor completor = new ArgumentCompletor(
- new SimpleCompletor(SQL_COMMANDS));
- completor.setStrict(false); // match at any position
- reader.addCompletor(completor);
-
- StringBuilder buffer = new StringBuilder();
- String line;
- boolean quit = false;
- while (!quit && (line = reader.readLine("SimpleDB> ")) != null) {
- // Split statements at ';': handles multiple statements on one
- // line, or one
- // statement spread across many lines
- while (line.indexOf(';') >= 0) {
- int split = line.indexOf(';');
- buffer.append(line.substring(0, split + 1));
- String cmd = buffer.toString().trim();
- cmd = cmd.substring(0, cmd.length() - 1).trim() + ";";
- byte[] statementBytes = cmd.getBytes("UTF-8");
- if (cmd.equalsIgnoreCase("quit;")
- || cmd.equalsIgnoreCase("exit;")) {
- shutdown();
- quit = true;
- break;
- }
-
- long startTime = System.currentTimeMillis();
- processNextStatement(new ByteArrayInputStream(
- statementBytes));
- long time = System.currentTimeMillis() - startTime;
- System.out.printf("----------------\n%.2f seconds\n\n",
- ((double) time / 1000.0));
-
- // Grab the remainder of the line
- line = line.substring(split + 1);
- buffer = new StringBuilder();
- }
- if (line.length() > 0) {
- buffer.append(line);
- buffer.append("\n");
- }
- }
- }
- }
-}
-
-class TupleArrayIterator implements DbIterator {
- /**
- *
- */
- private static final long serialVersionUID = 1L;
- ArrayList<Tuple> tups;
- Iterator<Tuple> it = null;
-
- public TupleArrayIterator(ArrayList<Tuple> tups) {
- this.tups = tups;
- }
-
- public void open() throws DbException, TransactionAbortedException {
- it = tups.iterator();
- }
-
- /** @return true if the iterator has more items. */
- public boolean hasNext() throws DbException, TransactionAbortedException {
- return it.hasNext();
- }
-
- /**
- * Gets the next tuple from the operator (typically implementing by reading
- * from a child operator or an access method).
- *
- * @return The next tuple in the iterator, or null if there are no more
- * tuples.
- */
- public Tuple next() throws DbException, TransactionAbortedException,
- NoSuchElementException {
- return it.next();
- }
-
- /**
- * Resets the iterator to the start.
- *
- * @throws DbException
- * When rewind is unsupported.
- */
- public void rewind() throws DbException, TransactionAbortedException {
- it = tups.iterator();
- }
-
- /**
- * Returns the TupleDesc associated with this DbIterator.
- */
- public TupleDesc getTupleDesc() {
- return tups.get(0).getTupleDesc();
- }
-
- /**
- * Closes the iterator.
- */
- public void close() {
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/ParsingException.java b/hw/hw3/starter-code/src/java/simpledb/ParsingException.java
deleted file mode 100644
index be8e93667f8c83c864c6d70ca88f71678c14c35c..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/ParsingException.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package simpledb;
-import java.lang.Exception;
-
-public class ParsingException extends Exception {
- public ParsingException(String string) {
- super(string);
- }
-
- public ParsingException(Exception e) {
- super(e);
- }
-
- /**
- *
- */
- private static final long serialVersionUID = 1L;
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Permissions.java b/hw/hw3/starter-code/src/java/simpledb/Permissions.java
deleted file mode 100644
index 3cdb3f6bc6180061b86637e5cad0b004e77367ad..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Permissions.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package simpledb;
-
-/**
- * Class representing requested permissions to a relation/file.
- * Private constructor with two static objects READ_ONLY and READ_WRITE that
- * represent the two levels of permission.
- */
-public class Permissions {
- int permLevel;
-
- private Permissions(int permLevel) {
- this.permLevel = permLevel;
- }
-
- public String toString() {
- if (permLevel == 0)
- return "READ_ONLY";
- if (permLevel == 1)
- return "READ_WRITE";
- return "UNKNOWN";
- }
-
- public static final Permissions READ_ONLY = new Permissions(0);
- public static final Permissions READ_WRITE = new Permissions(1);
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/PlanCache.java b/hw/hw3/starter-code/src/java/simpledb/PlanCache.java
deleted file mode 100644
index 43ccfe49931a84308f49f50d7443669f2c538113..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/PlanCache.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package simpledb;
-import java.util.HashMap;
-import java.util.Set;
-import java.util.Vector;
-
-/** A PlanCache is a helper class that can be used to store the best
- * way to order a given set of joins */
-public class PlanCache {
- HashMap<Set<LogicalJoinNode>,Vector<LogicalJoinNode>> bestOrders= new HashMap<Set<LogicalJoinNode>,Vector<LogicalJoinNode>>();
- HashMap<Set<LogicalJoinNode>,Double> bestCosts= new HashMap<Set<LogicalJoinNode>,Double>();
- HashMap<Set<LogicalJoinNode>,Integer> bestCardinalities = new HashMap<Set<LogicalJoinNode>,Integer>();
-
- /** Add a new cost, cardinality and ordering for a particular join set. Does not verify that the
- new cost is less than any previously added cost -- simply adds or replaces an existing plan for the
- specified join set
- @param s the set of joins for which a new ordering (plan) is being added
- @param cost the estimated cost of the specified plan
- @param card the estimatied cardinality of the specified plan
- @param order the ordering of the joins in the plan
- */
- void addPlan(Set<LogicalJoinNode> s, double cost, int card, Vector<LogicalJoinNode> order) {
- bestOrders.put(s,order);
- bestCosts.put(s,cost);
- bestCardinalities.put(s,card);
- }
-
- /** Find the best join order in the cache for the specified plan
- @param s the set of joins to look up the best order for
- @return the best order for s in the cache
- */
- Vector<LogicalJoinNode> getOrder(Set<LogicalJoinNode> s) {
- return bestOrders.get(s);
- }
-
- /** Find the cost of the best join order in the cache for the specified plan
- @param s the set of joins to look up the best cost for
- @return the cost of the best order for s in the cache
- */
- double getCost(Set<LogicalJoinNode> s) {
- return bestCosts.get(s);
- }
-
- /** Find the cardinality of the best join order in the cache for the specified plan
- @param s the set of joins to look up the best cardinality for
- @return the cardinality of the best order for s in the cache
- */
- int getCard(Set<LogicalJoinNode> s) {
- return bestCardinalities.get(s);
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Predicate.java b/hw/hw3/starter-code/src/java/simpledb/Predicate.java
deleted file mode 100644
index c751a2c2dd2f6ac2a6e8b5e493c5955f0f91b603..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Predicate.java
+++ /dev/null
@@ -1,111 +0,0 @@
-package simpledb;
-
-import java.io.Serializable;
-
-/**
- * Predicate compares tuples to a specified Field value.
- */
-public class Predicate implements Serializable {
-
- private static final long serialVersionUID = 1L;
-
- /** Constants used for return codes in Field.compare */
- public enum Op implements Serializable {
- EQUALS, GREATER_THAN, LESS_THAN, LESS_THAN_OR_EQ, GREATER_THAN_OR_EQ, LIKE, NOT_EQUALS;
-
- /**
- * Interface to access operations by integer value for command-line
- * convenience.
- *
- * @param i
- * a valid integer Op index
- */
- public static Op getOp(int i) {
- return values()[i];
- }
-
- public String toString() {
- if (this == EQUALS)
- return "=";
- if (this == GREATER_THAN)
- return ">";
- if (this == LESS_THAN)
- return "<";
- if (this == LESS_THAN_OR_EQ)
- return "<=";
- if (this == GREATER_THAN_OR_EQ)
- return ">=";
- if (this == LIKE)
- return "LIKE";
- if (this == NOT_EQUALS)
- return "<>";
- throw new IllegalStateException("impossible to reach here");
- }
-
- }
-
- /**
- * Constructor.
- *
- * @param field
- * field number of passed in tuples to compare against.
- * @param op
- * operation to use for comparison
- * @param operand
- * field value to compare passed in tuples to
- */
- public Predicate(int field, Op op, Field operand) {
- // some code goes here
- }
-
- /**
- * @return the field number
- */
- public int getField()
- {
- // some code goes here
- return -1;
- }
-
- /**
- * @return the operator
- */
- public Op getOp()
- {
- // some code goes here
- return null;
- }
-
- /**
- * @return the operand
- */
- public Field getOperand()
- {
- // some code goes here
- return null;
- }
-
- /**
- * Compares the field number of t specified in the constructor to the
- * operand field specified in the constructor using the operator specific in
- * the constructor. The comparison can be made through Field's compare
- * method.
- *
- * @param t
- * The tuple to compare against
- * @return true if the comparison is true, false otherwise.
- */
- public boolean filter(Tuple t) {
- // some code goes here
- return false;
- }
-
- /**
- * Returns something useful, like "f = field_id op = op_string operand =
- * operand_string
- */
- public String toString() {
- // some code goes here
- return "";
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Project.java b/hw/hw3/starter-code/src/java/simpledb/Project.java
deleted file mode 100644
index e54fef74fbaedee45f4913dd8f126ee8e5348a5a..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Project.java
+++ /dev/null
@@ -1,96 +0,0 @@
-package simpledb;
-
-import java.util.*;
-
-/**
- * Project is an operator that implements a relational projection.
- */
-public class Project extends Operator {
-
- private static final long serialVersionUID = 1L;
- private DbIterator child;
- private TupleDesc td;
- private ArrayList<Integer> outFieldIds;
-
- /**
- * Constructor accepts a child operator to read tuples to apply projection
- * to and a list of fields in output tuple
- *
- * @param fieldList
- * The ids of the fields child's tupleDesc to project out
- * @param typesList
- * the types of the fields in the final projection
- * @param child
- * The child operator
- */
- public Project(ArrayList<Integer> fieldList, ArrayList<Type> typesList,
- DbIterator child) {
- this(fieldList,typesList.toArray(new Type[]{}),child);
- }
-
- public Project(ArrayList<Integer> fieldList, Type[] types,
- DbIterator child) {
- this.child = child;
- outFieldIds = fieldList;
- String[] fieldAr = new String[fieldList.size()];
- TupleDesc childtd = child.getTupleDesc();
-
- for (int i = 0; i < fieldAr.length; i++) {
- fieldAr[i] = childtd.getFieldName(fieldList.get(i));
- }
- td = new TupleDesc(types, fieldAr);
- }
-
- public TupleDesc getTupleDesc() {
- return td;
- }
-
- public void open() throws DbException, NoSuchElementException,
- TransactionAbortedException {
- child.open();
- super.open();
- }
-
- public void close() {
- super.close();
- child.close();
- }
-
- public void rewind() throws DbException, TransactionAbortedException {
- child.rewind();
- }
-
- /**
- * Operator.fetchNext implementation. Iterates over tuples from the child
- * operator, projecting out the fields from the tuple
- *
- * @return The next tuple, or null if there are no more tuples
- */
- protected Tuple fetchNext() throws NoSuchElementException,
- TransactionAbortedException, DbException {
- while (child.hasNext()) {
- Tuple t = child.next();
- Tuple newTuple = new Tuple(td);
- newTuple.setRecordId(t.getRecordId());
- for (int i = 0; i < td.numFields(); i++) {
- newTuple.setField(i, t.getField(outFieldIds.get(i)));
- }
- return newTuple;
- }
- return null;
- }
-
- @Override
- public DbIterator[] getChildren() {
- return new DbIterator[] { this.child };
- }
-
- @Override
- public void setChildren(DbIterator[] children) {
- if (this.child!=children[0])
- {
- this.child = children[0];
- }
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Query.java b/hw/hw3/starter-code/src/java/simpledb/Query.java
deleted file mode 100644
index 45567f8db29599291bb3ea6d47c9646e71b3f219..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Query.java
+++ /dev/null
@@ -1,118 +0,0 @@
-package simpledb;
-
-import java.io.*;
-import java.util.*;
-
-/**
- * Query is a wrapper class to manage the execution of queries. It takes a query
- * plan in the form of a high level DbIterator (built by initiating the
- * constructors of query plans) and runs it as a part of a specified
- * transaction.
- *
- * @author Sam Madden
- */
-
-public class Query implements Serializable {
-
- private static final long serialVersionUID = 1L;
-
- transient private DbIterator op;
- transient private LogicalPlan logicalPlan;
- TransactionId tid;
- transient private boolean started = false;
-
- public TransactionId getTransactionId() {
- return this.tid;
- }
-
- public void setLogicalPlan(LogicalPlan lp) {
- this.logicalPlan = lp;
- }
-
- public LogicalPlan getLogicalPlan() {
- return this.logicalPlan;
- }
-
- public void setPhysicalPlan(DbIterator pp) {
- this.op = pp;
- }
-
- public DbIterator getPhysicalPlan() {
- return this.op;
- }
-
- public Query(TransactionId t) {
- tid = t;
- }
-
- public Query(DbIterator root, TransactionId t) {
- op = root;
- tid = t;
- }
-
- public void start() throws IOException, DbException,
- TransactionAbortedException {
- op.open();
-
- started = true;
- }
-
- public TupleDesc getOutputTupleDesc() {
- return this.op.getTupleDesc();
- }
-
- /** @return true if there are more tuples remaining. */
- public boolean hasNext() throws DbException, TransactionAbortedException {
- return op.hasNext();
- }
-
- /**
- * Returns the next tuple, or throws NoSuchElementException if the iterator
- * is closed.
- *
- * @return The next tuple in the iterator
- * @throws DbException
- * If there is an error in the database system
- * @throws NoSuchElementException
- * If the iterator has finished iterating
- * @throws TransactionAbortedException
- * If the transaction is aborted (e.g., due to a deadlock)
- */
- public Tuple next() throws DbException, NoSuchElementException,
- TransactionAbortedException {
- if (!started)
- throw new DbException("Database not started.");
-
- return op.next();
- }
-
- /** Close the iterator */
- public void close() throws IOException {
- op.close();
- started = false;
- }
-
- public void execute() throws IOException, DbException, TransactionAbortedException {
- TupleDesc td = this.getOutputTupleDesc();
-
- String names = "";
- for (int i = 0; i < td.numFields(); i++) {
- names += td.getFieldName(i) + "\t";
- }
- System.out.println(names);
- for (int i = 0; i < names.length() + td.numFields() * 4; i++) {
- System.out.print("-");
- }
- System.out.println("");
-
- this.start();
- int cnt = 0;
- while (this.hasNext()) {
- Tuple tup = this.next();
- System.out.println(tup);
- cnt++;
- }
- System.out.println("\n " + cnt + " rows.");
- this.close();
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/RecordId.java b/hw/hw3/starter-code/src/java/simpledb/RecordId.java
deleted file mode 100644
index d87865384181c0e34f203fd47a8f03daf0819e24..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/RecordId.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package simpledb;
-
-import java.io.Serializable;
-
-/**
- * A RecordId is a reference to a specific tuple on a specific page of a
- * specific table.
- */
-public class RecordId implements Serializable {
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Creates a new RecordId referring to the specified PageId and tuple
- * number.
- *
- * @param pid
- * the pageid of the page on which the tuple resides
- * @param tupleno
- * the tuple number within the page.
- */
- public RecordId(PageId pid, int tupleno) {
- // some code goes here
- }
-
- /**
- * @return the tuple number this RecordId references.
- */
- public int tupleno() {
- // some code goes here
- return 0;
- }
-
- /**
- * @return the page id this RecordId references.
- */
- public PageId getPageId() {
- // some code goes here
- return null;
- }
-
- /**
- * Two RecordId objects are considered equal if they represent the same
- * tuple.
- *
- * @return True if this and o represent the same tuple
- */
- @Override
- public boolean equals(Object o) {
- // some code goes here
- throw new UnsupportedOperationException("implement this");
- }
-
- /**
- * You should implement the hashCode() so that two equal RecordId instances
- * (with respect to equals()) have the same hashCode().
- *
- * @return An int that is the same for equal RecordId objects.
- */
- @Override
- public int hashCode() {
- // some code goes here
- throw new UnsupportedOperationException("implement this");
-
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/SeqScan.java b/hw/hw3/starter-code/src/java/simpledb/SeqScan.java
deleted file mode 100644
index 5f5f539d5134ba09dc48f296e1f17d6a27359489..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/SeqScan.java
+++ /dev/null
@@ -1,109 +0,0 @@
-package simpledb;
-
-import java.util.*;
-
-/**
- * SeqScan is an implementation of a sequential scan access method that reads
- * each tuple of a table in no particular order (e.g., as they are laid out on
- * disk).
- */
-public class SeqScan implements DbIterator {
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Creates a sequential scan over the specified table as a part of the
- * specified transaction.
- *
- * @param tid
- * The transaction this scan is running as a part of.
- * @param tableid
- * the table to scan.
- * @param tableAlias
- * the alias of this table (needed by the parser); the returned
- * tupleDesc should have fields with name tableAlias.fieldName
- * (note: this class is not responsible for handling a case where
- * tableAlias or fieldName are null. It shouldn't crash if they
- * are, but the resulting name can be null.fieldName,
- * tableAlias.null, or null.null).
- */
- public SeqScan(TransactionId tid, int tableid, String tableAlias) {
- // some code goes here
- }
-
- /**
- * @return
- * return the table name of the table the operator scans. This should
- * be the actual name of the table in the catalog of the database
- * */
- public String getTableName() {
- return null;
- }
-
- /**
- * @return Return the alias of the table this operator scans.
- * */
- public String getAlias()
- {
- // some code goes here
- return null;
- }
-
- /**
- * Reset the tableid, and tableAlias of this operator.
- * @param tableid
- * the table to scan.
- * @param tableAlias
- * the alias of this table (needed by the parser); the returned
- * tupleDesc should have fields with name tableAlias.fieldName
- * (note: this class is not responsible for handling a case where
- * tableAlias or fieldName are null. It shouldn't crash if they
- * are, but the resulting name can be null.fieldName,
- * tableAlias.null, or null.null).
- */
- public void reset(int tableid, String tableAlias) {
- // some code goes here
- }
-
- public SeqScan(TransactionId tid, int tableid) {
- this(tid, tableid, Database.getCatalog().getTableName(tableid));
- }
-
- public void open() throws DbException, TransactionAbortedException {
- // some code goes here
- }
-
- /**
- * Returns the TupleDesc with field names from the underlying HeapFile,
- * prefixed with the tableAlias string from the constructor. This prefix
- * becomes useful when joining tables containing a field(s) with the same
- * name.
- *
- * @return the TupleDesc with field names from the underlying HeapFile,
- * prefixed with the tableAlias string from the constructor.
- */
- public TupleDesc getTupleDesc() {
- // some code goes here
- return null;
- }
-
- public boolean hasNext() throws TransactionAbortedException, DbException {
- // some code goes here
- return false;
- }
-
- public Tuple next() throws NoSuchElementException,
- TransactionAbortedException, DbException {
- // some code goes here
- return null;
- }
-
- public void close() {
- // some code goes here
- }
-
- public void rewind() throws DbException, NoSuchElementException,
- TransactionAbortedException {
- // some code goes here
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/SimpleDb.java b/hw/hw3/starter-code/src/java/simpledb/SimpleDb.java
deleted file mode 100644
index 02f7636d4151125e2a123ef08022434040a40ce8..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/SimpleDb.java
+++ /dev/null
@@ -1,99 +0,0 @@
-package simpledb;
-import java.io.*;
-
-public class SimpleDb {
- public static void main (String args[])
- throws DbException, TransactionAbortedException, IOException {
- // convert a file
- if(args[0].equals("convert")) {
- try {
- if (args.length<3 || args.length>5){
- System.err.println("Unexpected number of arguments to convert ");
- return;
- }
- File sourceTxtFile=new File(args[1]);
- File targetDatFile=new File(args[1].replaceAll(".txt", ".dat"));
- int numOfAttributes=Integer.parseInt(args[2]);
- Type[] ts = new Type[numOfAttributes];
- char fieldSeparator=',';
-
- if (args.length == 3)
- for (int i=0;i<numOfAttributes;i++)
- ts[i]=Type.INT_TYPE;
- else {
- String typeString=args[3];
- String[] typeStringAr = typeString.split(",");
- if (typeStringAr.length!=numOfAttributes)
- {
- System.err.println("The number of types does not agree with the number of columns");
- return;
- }
- int index=0;
- for (String s: typeStringAr) {
- if (s.toLowerCase().equals("int"))
- ts[index++]=Type.INT_TYPE;
- else if (s.toLowerCase().equals("string"))
- ts[index++]=Type.STRING_TYPE;
- else {
- System.err.println("Unknown type " + s);
- return;
- }
- }
- if (args.length==5)
- fieldSeparator=args[4].charAt(0);
- }
-
- HeapFileEncoder.convert(sourceTxtFile,targetDatFile,
- BufferPool.getPageSize(),numOfAttributes,ts,fieldSeparator);
-
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- } else if (args[0].equals("print")) {
- File tableFile = new File(args[1]);
- int columns = Integer.parseInt(args[2]);
- DbFile table = Utility.openHeapFile(columns, tableFile);
- TransactionId tid = new TransactionId();
- DbFileIterator it = table.iterator(tid);
-
- if(null == it){
- System.out.println("Error: method HeapFile.iterator(TransactionId tid) not yet implemented!");
- } else {
- it.open();
- while (it.hasNext()) {
- Tuple t = it.next();
- System.out.println(t);
- }
- it.close();
- }
- }
- else if (args[0].equals("parser")) {
- // Strip the first argument and call the parser
- String[] newargs = new String[args.length-1];
- for (int i = 1; i < args.length; ++i) {
- newargs[i-1] = args[i];
- }
-
- try {
- //dynamically load Parser -- if it doesn't exist, print error message
- Class<?> c = Class.forName("simpledb.Parser");
- Class<?> s = String[].class;
-
- java.lang.reflect.Method m = c.getMethod("main", s);
- m.invoke(null, (java.lang.Object)newargs);
- } catch (ClassNotFoundException cne) {
- System.out.println("Class Parser not found -- perhaps you are trying to run the parser as a part of lab1?");
- }
- catch (Exception e) {
- System.out.println("Error in parser.");
- e.printStackTrace();
- }
-
- }
- else {
- System.err.println("Unknown command: " + args[0]);
- System.exit(1);
- }
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/StringAggregator.java b/hw/hw3/starter-code/src/java/simpledb/StringAggregator.java
deleted file mode 100644
index 04fb6579aa2b87efc46d44f9aaae8ea890e284a4..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/StringAggregator.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package simpledb;
-
-/**
- * Knows how to compute some aggregate over a set of StringFields.
- */
-public class StringAggregator implements Aggregator {
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Aggregate constructor
- * @param gbfield the 0-based index of the group-by field in the tuple, or NO_GROUPING if there is no grouping
- * @param gbfieldtype the type of the group by field (e.g., Type.INT_TYPE), or null if there is no grouping
- * @param afield the 0-based index of the aggregate field in the tuple
- * @param what aggregation operator to use -- only supports COUNT
- * @throws IllegalArgumentException if what != COUNT
- */
-
- public StringAggregator(int gbfield, Type gbfieldtype, int afield, Op what) {
- // some code goes here
- }
-
- /**
- * Merge a new tuple into the aggregate, grouping as indicated in the constructor
- * @param tup the Tuple containing an aggregate field and a group-by field
- */
- public void mergeTupleIntoGroup(Tuple tup) {
- // some code goes here
- }
-
- /**
- * Create a DbIterator over group aggregate results.
- *
- * @return a DbIterator whose tuples are the pair (groupVal,
- * aggregateVal) if using group, or a single (aggregateVal) if no
- * grouping. The aggregateVal is determined by the type of
- * aggregate specified in the constructor.
- */
- public DbIterator iterator() {
- // some code goes here
- throw new UnsupportedOperationException("please implement me for lab2");
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/StringField.java b/hw/hw3/starter-code/src/java/simpledb/StringField.java
deleted file mode 100644
index 309ce07ab787957695e389f6d99d0742816f3edf..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/StringField.java
+++ /dev/null
@@ -1,115 +0,0 @@
-package simpledb;
-
-import java.io.*;
-
-/**
- * Instance of Field that stores a single String of a fixed length.
- */
-public class StringField implements Field {
-
- private static final long serialVersionUID = 1L;
-
- private final String value;
- private final int maxSize;
-
- public String getValue() {
- return value;
- }
-
- /**
- * Constructor.
- *
- * @param s
- * The value of this field.
- * @param maxSize
- * The maximum size of this string
- */
- public StringField(String s, int maxSize) {
- this.maxSize = maxSize;
-
- if (s.length() > maxSize)
- value = s.substring(0, maxSize);
- else
- value = s;
- }
-
- public String toString() {
- return value;
- }
-
- public int hashCode() {
- return value.hashCode();
- }
-
- public boolean equals(Object field) {
- return ((StringField) field).value.equals(value);
- }
-
- /**
- * Write this string to dos. Always writes maxSize + 4 bytes to the passed
- * in dos. First four bytes are string length, next bytes are string, with
- * remainder padded with 0 to maxSize.
- *
- * @param dos
- * Where the string is written
- */
- public void serialize(DataOutputStream dos) throws IOException {
- String s = value;
- int overflow = maxSize - s.length();
- if (overflow < 0) {
- String news = s.substring(0, maxSize);
- s = news;
- }
- dos.writeInt(s.length());
- dos.writeBytes(s);
- while (overflow-- > 0)
- dos.write((byte) 0);
- }
-
- /**
- * Compare the specified field to the value of this Field. Return semantics
- * are as specified by Field.compare
- *
- * @throws IllegalCastException
- * if val is not a StringField
- * @see Field#compare
- */
- public boolean compare(Predicate.Op op, Field val) {
-
- StringField iVal = (StringField) val;
- int cmpVal = value.compareTo(iVal.value);
-
- switch (op) {
- case EQUALS:
- return cmpVal == 0;
-
- case NOT_EQUALS:
- return cmpVal != 0;
-
- case GREATER_THAN:
- return cmpVal > 0;
-
- case GREATER_THAN_OR_EQ:
- return cmpVal >= 0;
-
- case LESS_THAN:
- return cmpVal < 0;
-
- case LESS_THAN_OR_EQ:
- return cmpVal <= 0;
-
- case LIKE:
- return value.indexOf(iVal.value) >= 0;
- }
-
- return false;
- }
-
- /**
- * @return the Type for this Field
- */
- public Type getType() {
-
- return Type.STRING_TYPE;
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/TableStats.java b/hw/hw3/starter-code/src/java/simpledb/TableStats.java
deleted file mode 100644
index 9829cfe4c98d8099b59927d3c9505df05cda8e4e..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/TableStats.java
+++ /dev/null
@@ -1,162 +0,0 @@
-package simpledb;
-
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * TableStats represents statistics (e.g., histograms) about base tables in a
- * query.
- *
- * This class is not needed in implementing lab1 and lab2.
- */
-public class TableStats {
-
- private static final ConcurrentHashMap<String, TableStats> statsMap = new ConcurrentHashMap<String, TableStats>();
-
- static final int IOCOSTPERPAGE = 1000;
-
- public static TableStats getTableStats(String tablename) {
- return statsMap.get(tablename);
- }
-
- public static void setTableStats(String tablename, TableStats stats) {
- statsMap.put(tablename, stats);
- }
-
- public static void setStatsMap(HashMap<String,TableStats> s)
- {
- try {
- java.lang.reflect.Field statsMapF = TableStats.class.getDeclaredField("statsMap");
- statsMapF.setAccessible(true);
- statsMapF.set(null, s);
- } catch (NoSuchFieldException e) {
- e.printStackTrace();
- } catch (SecurityException e) {
- e.printStackTrace();
- } catch (IllegalArgumentException e) {
- e.printStackTrace();
- } catch (IllegalAccessException e) {
- e.printStackTrace();
- }
-
- }
-
- public static Map<String, TableStats> getStatsMap() {
- return statsMap;
- }
-
- public static void computeStatistics() {
- Iterator<Integer> tableIt = Database.getCatalog().tableIdIterator();
-
- System.out.println("Computing table stats.");
- while (tableIt.hasNext()) {
- int tableid = tableIt.next();
- TableStats s = new TableStats(tableid, IOCOSTPERPAGE);
- setTableStats(Database.getCatalog().getTableName(tableid), s);
- }
- System.out.println("Done.");
- }
-
- /**
- * Number of bins for the histogram. Feel free to increase this value over
- * 100, though our tests assume that you have at least 100 bins in your
- * histograms.
- */
- static final int NUM_HIST_BINS = 100;
-
- /**
- * Create a new TableStats object, that keeps track of statistics on each
- * column of a table
- *
- * @param tableid
- * The table over which to compute statistics
- * @param ioCostPerPage
- * The cost per page of IO. This doesn't differentiate between
- * sequential-scan IO and disk seeks.
- */
- public TableStats(int tableid, int ioCostPerPage) {
- // For this function, you'll have to get the
- // DbFile for the table in question,
- // then scan through its tuples and calculate
- // the values that you need.
- // You should try to do this reasonably efficiently, but you don't
- // necessarily have to (for example) do everything
- // in a single scan of the table.
- // some code goes here
- }
-
- /**
- * Estimates the cost of sequentially scanning the file, given that the cost
- * to read a page is costPerPageIO. You can assume that there are no seeks
- * and that no pages are in the buffer pool.
- *
- * Also, assume that your hard drive can only read entire pages at once, so
- * if the last page of the table only has one tuple on it, it's just as
- * expensive to read as a full page. (Most real hard drives can't
- * efficiently address regions smaller than a page at a time.)
- *
- * @return The estimated cost of scanning the table.
- */
- public double estimateScanCost() {
- // some code goes here
- return 0;
- }
-
- /**
- * This method returns the number of tuples in the relation, given that a
- * predicate with selectivity selectivityFactor is applied.
- *
- * @param selectivityFactor
- * The selectivity of any predicates over the table
- * @return The estimated cardinality of the scan with the specified
- * selectivityFactor
- */
- public int estimateTableCardinality(double selectivityFactor) {
- // some code goes here
- return 0;
- }
-
- /**
- * The average selectivity of the field under op.
- * @param field
- * the index of the field
- * @param op
- * the operator in the predicate
- * The semantic of the method is that, given the table, and then given a
- * tuple, of which we do not know the value of the field, return the
- * expected selectivity. You may estimate this value from the histograms.
- * */
- public double avgSelectivity(int field, Predicate.Op op) {
- // some code goes here
- return 1.0;
- }
-
- /**
- * Estimate the selectivity of predicate <tt>field op constant</tt> on the
- * table.
- *
- * @param field
- * The field over which the predicate ranges
- * @param op
- * The logical operation in the predicate
- * @param constant
- * The value against which the field is compared
- * @return The estimated selectivity (fraction of tuples that satisfy) the
- * predicate
- */
- public double estimateSelectivity(int field, Predicate.Op op, Field constant) {
- // some code goes here
- return 1.0;
- }
-
- /**
- * return the total number of tuples in this table
- * */
- public int totalTuples() {
- // some code goes here
- return 0;
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Transaction.java b/hw/hw3/starter-code/src/java/simpledb/Transaction.java
deleted file mode 100644
index 8db3b1842540d80700823b0334937096354cbcff..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Transaction.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package simpledb;
-
-import java.io.*;
-
-/**
- * Transaction encapsulates information about the state of
- * a transaction and manages transaction commit / abort.
- */
-
-public class Transaction {
- private final TransactionId tid;
- volatile boolean started = false;
-
- public Transaction() {
- tid = new TransactionId();
- }
-
- /** Start the transaction running */
- public void start() {
- started = true;
- try {
- Database.getLogFile().logXactionBegin(tid);
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
-
- public TransactionId getId() {
- return tid;
- }
-
- /** Finish the transaction */
- public void commit() throws IOException {
- transactionComplete(false);
- }
-
- /** Finish the transaction */
- public void abort() throws IOException {
- transactionComplete(true);
- }
-
- /** Handle the details of transaction commit / abort */
- public void transactionComplete(boolean abort) throws IOException {
-
- if (started) {
- //write commit / abort records
- if (abort) {
- Database.getLogFile().logAbort(tid); //does rollback too
- } else {
- //write all the dirty pages for this transaction out
- Database.getBufferPool().flushPages(tid);
- Database.getLogFile().logCommit(tid);
- }
-
- try {
-
- Database.getBufferPool().transactionComplete(tid, !abort); // release locks
-
- } catch (IOException e) {
- e.printStackTrace();
- }
-
- //setting this here means we could possibly write multiple abort records -- OK?
- started = false;
- }
-
- }
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/TransactionAbortedException.java b/hw/hw3/starter-code/src/java/simpledb/TransactionAbortedException.java
deleted file mode 100644
index fb8c38f1bff27265d5708e6e56c8294c5a3c411f..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/TransactionAbortedException.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package simpledb;
-
-import java.lang.Exception;
-
-/** Exception that is thrown when a transaction has aborted. */
-public class TransactionAbortedException extends Exception {
- private static final long serialVersionUID = 1L;
-
- public TransactionAbortedException() {
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/TransactionId.java b/hw/hw3/starter-code/src/java/simpledb/TransactionId.java
deleted file mode 100644
index ebdb182a1b8cf14a3fe598398acd3c76cd5c745c..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/TransactionId.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package simpledb;
-
-import java.io.Serializable;
-import java.util.concurrent.atomic.AtomicLong;
-
-/**
- * TransactionId is a class that contains the identifier of a transaction.
- */
-public class TransactionId implements Serializable {
-
- private static final long serialVersionUID = 1L;
-
- static AtomicLong counter = new AtomicLong(0);
- final long myid;
-
- public TransactionId() {
- myid = counter.getAndIncrement();
- }
-
- public long getId() {
- return myid;
- }
-
- public boolean equals(Object tid) {
- return ((TransactionId) tid).myid == myid;
- }
-
- public int hashCode() {
- return (int) myid;
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Tuple.java b/hw/hw3/starter-code/src/java/simpledb/Tuple.java
deleted file mode 100644
index 2ca624a8704c7cfbdf2bccc4a3042479b4225c0c..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Tuple.java
+++ /dev/null
@@ -1,107 +0,0 @@
-package simpledb;
-
-import java.io.Serializable;
-import java.util.Arrays;
-import java.util.Iterator;
-
-/**
- * Tuple maintains information about the contents of a tuple. Tuples have a
- * specified schema specified by a TupleDesc object and contain Field objects
- * with the data for each field.
- */
-public class Tuple implements Serializable {
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Create a new tuple with the specified schema (type).
- *
- * @param td
- * the schema of this tuple. It must be a valid TupleDesc
- * instance with at least one field.
- */
- public Tuple(TupleDesc td) {
- // some code goes here
- }
-
- /**
- * @return The TupleDesc representing the schema of this tuple.
- */
- public TupleDesc getTupleDesc() {
- // some code goes here
- return null;
- }
-
- /**
- * @return The RecordId representing the location of this tuple on disk. May
- * be null.
- */
- public RecordId getRecordId() {
- // some code goes here
- return null;
- }
-
- /**
- * Set the RecordId information for this tuple.
- *
- * @param rid
- * the new RecordId for this tuple.
- */
- public void setRecordId(RecordId rid) {
- // some code goes here
- }
-
- /**
- * Change the value of the ith field of this tuple.
- *
- * @param i
- * index of the field to change. It must be a valid index.
- * @param f
- * new value for the field.
- */
- public void setField(int i, Field f) {
- // some code goes here
- }
-
- /**
- * @return the value of the ith field, or null if it has not been set.
- *
- * @param i
- * field index to return. Must be a valid index.
- */
- public Field getField(int i) {
- // some code goes here
- return null;
- }
-
- /**
- * Returns the contents of this Tuple as a string. Note that to pass the
- * system tests, the format needs to be as follows:
- *
- * column1\tcolumn2\tcolumn3\t...\tcolumnN\n
- *
- * where \t is any whitespace, except newline, and \n is a newline
- */
- public String toString() {
- // some code goes here
- throw new UnsupportedOperationException("Implement this");
- }
-
- /**
- * @return
- * An iterator which iterates over all the fields of this tuple
- * */
- public Iterator<Field> fields()
- {
- // some code goes here
- return null;
- }
-
- /**
- * reset the TupleDesc of thi tuple
- * */
- public void resetTupleDesc(TupleDesc td)
- {
- // some code goes here
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/TupleDesc.java b/hw/hw3/starter-code/src/java/simpledb/TupleDesc.java
deleted file mode 100644
index c7ba3eec921fed0b1f34e873cd437dad6ccf13b2..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/TupleDesc.java
+++ /dev/null
@@ -1,183 +0,0 @@
-package simpledb;
-
-import java.io.Serializable;
-import java.util.*;
-
-/**
- * TupleDesc describes the schema of a tuple.
- */
-public class TupleDesc implements Serializable {
-
- /**
- * A help class to facilitate organizing the information of each field
- * */
- public static class TDItem implements Serializable {
-
- private static final long serialVersionUID = 1L;
-
- /**
- * The type of the field
- * */
- public final Type fieldType;
-
- /**
- * The name of the field
- * */
- public final String fieldName;
-
- public TDItem(Type t, String n) {
- this.fieldName = n;
- this.fieldType = t;
- }
-
- public String toString() {
- return fieldName + "(" + fieldType + ")";
- }
- }
-
- /**
- * @return
- * An iterator which iterates over all the field TDItems
- * that are included in this TupleDesc
- * */
- public Iterator<TDItem> iterator() {
- // some code goes here
- return null;
- }
-
- private static final long serialVersionUID = 1L;
-
- /**
- * Create a new TupleDesc with typeAr.length fields with fields of the
- * specified types, with associated named fields.
- *
- * @param typeAr
- * array specifying the number of and types of fields in this
- * TupleDesc. It must contain at least one entry.
- * @param fieldAr
- * array specifying the names of the fields. Note that names may
- * be null.
- */
- public TupleDesc(Type[] typeAr, String[] fieldAr) {
- // some code goes here
- }
-
- /**
- * Constructor. Create a new tuple desc with typeAr.length fields with
- * fields of the specified types, with anonymous (unnamed) fields.
- *
- * @param typeAr
- * array specifying the number of and types of fields in this
- * TupleDesc. It must contain at least one entry.
- */
- public TupleDesc(Type[] typeAr) {
- // some code goes here
- }
-
- /**
- * @return the number of fields in this TupleDesc
- */
- public int numFields() {
- // some code goes here
- return 0;
- }
-
- /**
- * Gets the (possibly null) field name of the ith field of this TupleDesc.
- *
- * @param i
- * index of the field name to return. It must be a valid index.
- * @return the name of the ith field
- * @throws NoSuchElementException
- * if i is not a valid field reference.
- */
- public String getFieldName(int i) throws NoSuchElementException {
- // some code goes here
- return null;
- }
-
- /**
- * Gets the type of the ith field of this TupleDesc.
- *
- * @param i
- * The index of the field to get the type of. It must be a valid
- * index.
- * @return the type of the ith field
- * @throws NoSuchElementException
- * if i is not a valid field reference.
- */
- public Type getFieldType(int i) throws NoSuchElementException {
- // some code goes here
- return null;
- }
-
- /**
- * Find the index of the field with a given name.
- *
- * @param name
- * name of the field.
- * @return the index of the field that is first to have the given name.
- * @throws NoSuchElementException
- * if no field with a matching name is found.
- */
- public int fieldNameToIndex(String name) throws NoSuchElementException {
- // some code goes here
- return 0;
- }
-
- /**
- * @return The size (in bytes) of tuples corresponding to this TupleDesc.
- * Note that tuples from a given TupleDesc are of a fixed size.
- */
- public int getSize() {
- // some code goes here
- return 0;
- }
-
- /**
- * Merge two TupleDescs into one, with td1.numFields + td2.numFields fields,
- * with the first td1.numFields coming from td1 and the remaining from td2.
- *
- * @param td1
- * The TupleDesc with the first fields of the new TupleDesc
- * @param td2
- * The TupleDesc with the last fields of the TupleDesc
- * @return the new TupleDesc
- */
- public static TupleDesc merge(TupleDesc td1, TupleDesc td2) {
- // some code goes here
- return null;
- }
-
- /**
- * Compares the specified object with this TupleDesc for equality. Two
- * TupleDescs are considered equal if they are the same size and if the n-th
- * type in this TupleDesc is equal to the n-th type in td.
- *
- * @param o
- * the Object to be compared for equality with this TupleDesc.
- * @return true if the object is equal to this TupleDesc.
- */
- public boolean equals(Object o) {
- // some code goes here
- return false;
- }
-
- public int hashCode() {
- // If you want to use TupleDesc as keys for HashMap, implement this so
- // that equal objects have equals hashCode() results
- throw new UnsupportedOperationException("unimplemented");
- }
-
- /**
- * Returns a String describing this descriptor. It should be of the form
- * "fieldType[0](fieldName[0]), ..., fieldType[M](fieldName[M])", although
- * the exact format does not matter.
- *
- * @return String describing this descriptor.
- */
- public String toString() {
- // some code goes here
- return "";
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/TupleIterator.java b/hw/hw3/starter-code/src/java/simpledb/TupleIterator.java
deleted file mode 100644
index 496b8071ab191e8c183d57952cfaf8fbe2c199ed..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/TupleIterator.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package simpledb;
-
-import java.util.*;
-
-/**
- * Implements a DbIterator by wrapping an Iterable<Tuple>.
- */
-public class TupleIterator implements DbIterator {
- /**
- *
- */
- private static final long serialVersionUID = 1L;
- Iterator<Tuple> i = null;
- TupleDesc td = null;
- Iterable<Tuple> tuples = null;
-
- /**
- * Constructs an iterator from the specified Iterable, and the specified
- * descriptor.
- *
- * @param tuples
- * The set of tuples to iterate over
- */
- public TupleIterator(TupleDesc td, Iterable<Tuple> tuples) {
- this.td = td;
- this.tuples = tuples;
-
- // check that all tuples are the right TupleDesc
- for (Tuple t : tuples) {
- if (!t.getTupleDesc().equals(td))
- throw new IllegalArgumentException(
- "incompatible tuple in tuple set");
- }
- }
-
- public void open() {
- i = tuples.iterator();
- }
-
- public boolean hasNext() {
- return i.hasNext();
- }
-
- public Tuple next() {
- return i.next();
- }
-
- public void rewind() {
- close();
- open();
- }
-
- public TupleDesc getTupleDesc() {
- return td;
- }
-
- public void close() {
- i = null;
- }
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Type.java b/hw/hw3/starter-code/src/java/simpledb/Type.java
deleted file mode 100644
index b1f128614eb441d569cc6ebbe80cb29b72e58257..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Type.java
+++ /dev/null
@@ -1,63 +0,0 @@
-package simpledb;
-
-import java.text.ParseException;
-import java.io.*;
-
-/**
- * Class representing a type in SimpleDB.
- * Types are static objects defined by this class; hence, the Type
- * constructor is private.
- */
-public enum Type implements Serializable {
- INT_TYPE() {
- @Override
- public int getLen() {
- return 4;
- }
-
- @Override
- public Field parse(DataInputStream dis) throws ParseException {
- try {
- return new IntField(dis.readInt());
- } catch (IOException e) {
- throw new ParseException("couldn't parse", 0);
- }
- }
-
- }, STRING_TYPE() {
- @Override
- public int getLen() {
- return STRING_LEN+4;
- }
-
- @Override
- public Field parse(DataInputStream dis) throws ParseException {
- try {
- int strLen = dis.readInt();
- byte bs[] = new byte[strLen];
- dis.read(bs);
- dis.skipBytes(STRING_LEN-strLen);
- return new StringField(new String(bs), STRING_LEN);
- } catch (IOException e) {
- throw new ParseException("couldn't parse", 0);
- }
- }
- };
-
- public static final int STRING_LEN = 128;
-
- /**
- * @return the number of bytes required to store a field of this type.
- */
- public abstract int getLen();
-
- /**
- * @return a Field object of the same type as this object that has contents
- * read from the specified DataInputStream.
- * @param dis The input stream to read from
- * @throws ParseException if the data read from the input stream is not
- * of the appropriate type.
- */
- public abstract Field parse(DataInputStream dis) throws ParseException;
-
-}
diff --git a/hw/hw3/starter-code/src/java/simpledb/Utility.java b/hw/hw3/starter-code/src/java/simpledb/Utility.java
deleted file mode 100644
index 5e77d1f45b6d0a88728980f3bee33d477667fae0..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/src/java/simpledb/Utility.java
+++ /dev/null
@@ -1,157 +0,0 @@
-package simpledb;
-
-import java.io.*;
-import java.util.ArrayList;
-import java.util.UUID;
-
-/** Helper methods used for testing and implementing random features. */
-public class Utility {
- /**
- * @return a Type array of length len populated with Type.INT_TYPE
- */
- public static Type[] getTypes(int len) {
- Type[] types = new Type[len];
- for (int i = 0; i < len; ++i)
- types[i] = Type.INT_TYPE;
- return types;
- }
-
- /**
- * @return a String array of length len populated with the (possibly null) strings in val,
- * and an appended increasing integer at the end (val1, val2, etc.).
- */
- public static String[] getStrings(int len, String val) {
- String[] strings = new String[len];
- for (int i = 0; i < len; ++i)
- strings[i] = val + i;
- return strings;
- }
-
- /**
- * @return a TupleDesc with n fields of type Type.INT_TYPE, each named
- * name + n (name1, name2, etc.).
- */
- public static TupleDesc getTupleDesc(int n, String name) {
- return new TupleDesc(getTypes(n), getStrings(n, name));
- }
-
- /**
- * @return a TupleDesc with n fields of type Type.INT_TYPE
- */
- public static TupleDesc getTupleDesc(int n) {
- return new TupleDesc(getTypes(n));
- }
-
- /**
- * @return a Tuple with a single IntField with value n and with
- * RecordId(HeapPageId(1,2), 3)
- */
- public static Tuple getHeapTuple(int n) {
- Tuple tup = new Tuple(getTupleDesc(1));
- tup.setRecordId(new RecordId(new HeapPageId(1, 2), 3));
- tup.setField(0, new IntField(n));
- return tup;
- }
-
- /**
- * @return a Tuple with an IntField for every element of tupdata
- * and RecordId(HeapPageId(1, 2), 3)
- */
- public static Tuple getHeapTuple(int[] tupdata) {
- Tuple tup = new Tuple(getTupleDesc(tupdata.length));
- tup.setRecordId(new RecordId(new HeapPageId(1, 2), 3));
- for (int i = 0; i < tupdata.length; ++i)
- tup.setField(i, new IntField(tupdata[i]));
- return tup;
- }
-
- /**
- * @return a Tuple with a 'width' IntFields each with value n and
- * with RecordId(HeapPageId(1, 2), 3)
- */
- public static Tuple getHeapTuple(int n, int width) {
- Tuple tup = new Tuple(getTupleDesc(width));
- tup.setRecordId(new RecordId(new HeapPageId(1, 2), 3));
- for (int i = 0; i < width; ++i)
- tup.setField(i, new IntField(n));
- return tup;
- }
-
- /**
- * @return a Tuple with a 'width' IntFields with the value tupledata[i]
- * in each field.
- * do not set it's RecordId, hence do not distinguish which
- * sort of file it belongs to.
- */
- public static Tuple getTuple(int[] tupledata, int width) {
- if(tupledata.length != width) {
- System.out.println("get Hash Tuple has the wrong length~");
- System.exit(1);
- }
- Tuple tup = new Tuple(getTupleDesc(width));
- for (int i = 0; i < width; ++i)
- tup.setField(i, new IntField(tupledata[i]));
- return tup;
- }
-
- /**
- * A utility method to create a new HeapFile with a single empty page,
- * assuming the path does not already exist. If the path exists, the file
- * will be overwritten. The new table will be added to the Catalog with
- * the specified number of columns as IntFields.
- */
- public static HeapFile createEmptyHeapFile(String path, int cols)
- throws IOException {
- File f = new File(path);
- // touch the file
- FileOutputStream fos = new FileOutputStream(f);
- fos.write(new byte[0]);
- fos.close();
-
- HeapFile hf = openHeapFile(cols, f);
- HeapPageId pid = new HeapPageId(hf.getId(), 0);
-
- HeapPage page = null;
- try {
- page = new HeapPage(pid, HeapPage.createEmptyPageData());
- } catch (IOException e) {
- // this should never happen for an empty page; bail;
- throw new RuntimeException("failed to create empty page in HeapFile");
- }
-
- hf.writePage(page);
- return hf;
- }
-
- /** Opens a HeapFile and adds it to the catalog.
- *
- * @param cols number of columns in the table.
- * @param f location of the file storing the table.
- * @return the opened table.
- */
- public static HeapFile openHeapFile(int cols, File f) {
- // create the HeapFile and add it to the catalog
- TupleDesc td = getTupleDesc(cols);
- HeapFile hf = new HeapFile(f, td);
- Database.getCatalog().addTable(hf, UUID.randomUUID().toString());
- return hf;
- }
-
- public static HeapFile openHeapFile(int cols, String colPrefix, File f) {
- // create the HeapFile and add it to the catalog
- TupleDesc td = getTupleDesc(cols, colPrefix);
- HeapFile hf = new HeapFile(f, td);
- Database.getCatalog().addTable(hf, UUID.randomUUID().toString());
- return hf;
- }
-
- public static String listToString(ArrayList<Integer> list) {
- String out = "";
- for (Integer i : list) {
- if (out.length() > 0) out += "\t";
- out += i;
- }
- return out;
- }
-}
-
diff --git a/hw/hw3/starter-code/test/simpledb/AggregateTest.java b/hw/hw3/starter-code/test/simpledb/AggregateTest.java
deleted file mode 100644
index 38217d2a9288d78b49791c2ecb5177697e5db319..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/AggregateTest.java
+++ /dev/null
@@ -1,186 +0,0 @@
-package simpledb;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import junit.framework.JUnit4TestAdapter;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import simpledb.systemtest.SimpleDbTestBase;
-
-public class AggregateTest extends SimpleDbTestBase {
-
- int width1 = 2;
- DbIterator scan1;
- DbIterator scan2;
- DbIterator scan3;
-
- DbIterator sum;
- DbIterator sumstring;
-
- DbIterator avg;
- DbIterator max;
- DbIterator min;
- DbIterator count;
-
- /**
- * Initialize each unit test
- */
- @Before public void createTupleLists() throws Exception {
- this.scan1 = TestUtil.createTupleList(width1,
- new int[] { 1, 2,
- 1, 4,
- 1, 6,
- 3, 2,
- 3, 4,
- 3, 6,
- 5, 7 });
- this.scan2 = TestUtil.createTupleList(width1,
- new Object[] { 1, "a",
- 1, "a",
- 1, "a",
- 3, "a",
- 3, "a",
- 3, "a",
- 5, "a" });
- this.scan3 = TestUtil.createTupleList(width1,
- new Object[] { "a", 2,
- "a", 4,
- "a", 6,
- "b", 2,
- "b", 4,
- "b", 6,
- "c", 7 });
-
- this.sum = TestUtil.createTupleList(width1,
- new int[] { 1, 12,
- 3, 12,
- 5, 7 });
- this.sumstring = TestUtil.createTupleList(width1,
- new Object[] { "a", 12,
- "b", 12,
- "c", 7 });
-
- this.avg = TestUtil.createTupleList(width1,
- new int[] { 1, 4,
- 3, 4,
- 5, 7 });
- this.min = TestUtil.createTupleList(width1,
- new int[] { 1, 2,
- 3, 2,
- 5, 7 });
- this.max = TestUtil.createTupleList(width1,
- new int[] { 1, 6,
- 3, 6,
- 5, 7 });
- this.count = TestUtil.createTupleList(width1,
- new int[] { 1, 3,
- 3, 3,
- 5, 1 });
-
- }
-
- /**
- * Unit test for Aggregate.getTupleDesc()
- */
- @Test public void getTupleDesc() {
- Aggregate op = new Aggregate(scan1, 0, 0,
- Aggregator.Op.MIN);
- TupleDesc expected = Utility.getTupleDesc(2);
- TupleDesc actual = op.getTupleDesc();
- assertEquals(expected, actual);
- }
-
- /**
- * Unit test for Aggregate.rewind()
- */
- @Test public void rewind() throws Exception {
- Aggregate op = new Aggregate(scan1, 1, 0,
- Aggregator.Op.MIN);
- op.open();
- while (op.hasNext()) {
- assertNotNull(op.next());
- }
- assertTrue(TestUtil.checkExhausted(op));
-
- op.rewind();
- min.open();
- TestUtil.matchAllTuples(min, op);
- }
-
- /**
- * Unit test for Aggregate.getNext() using a count aggregate with string types
- */
- @Test public void countStringAggregate() throws Exception {
- Aggregate op = new Aggregate(scan2, 1, 0,
- Aggregator.Op.COUNT);
- op.open();
- count.open();
- TestUtil.matchAllTuples(count, op);
- }
-
- /**
- * Unit test for Aggregate.getNext() using a count aggregate with string types
- */
- @Test public void sumStringGroupBy() throws Exception {
- Aggregate op = new Aggregate(scan3, 1, 0,
- Aggregator.Op.SUM);
- op.open();
- sumstring.open();
- TestUtil.matchAllTuples(sumstring, op);
- }
-
- /**
- * Unit test for Aggregate.getNext() using a sum aggregate
- */
- @Test public void sumAggregate() throws Exception {
- Aggregate op = new Aggregate(scan1, 1, 0,
- Aggregator.Op.SUM);
- op.open();
- sum.open();
- TestUtil.matchAllTuples(sum, op);
- }
-
- /**
- * Unit test for Aggregate.getNext() using an avg aggregate
- */
- @Test public void avgAggregate() throws Exception {
- Aggregate op = new Aggregate(scan1, 1, 0,
- Aggregator.Op.AVG);
- op.open();
- avg.open();
- TestUtil.matchAllTuples(avg, op);
- }
-
- /**
- * Unit test for Aggregate.getNext() using a max aggregate
- */
- @Test public void maxAggregate() throws Exception {
- Aggregate op = new Aggregate(scan1, 1, 0,
- Aggregator.Op.MAX);
- op.open();
- max.open();
- TestUtil.matchAllTuples(max, op);
- }
-
- /**
- * Unit test for Aggregate.getNext() using a min aggregate
- */
- @Test public void minAggregate() throws Exception {
- Aggregate op = new Aggregate(scan1, 1, 0,
- Aggregator.Op.MIN);
- op.open();
- min.open();
- TestUtil.matchAllTuples(min, op);
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(AggregateTest.class);
- }
-}
-
diff --git a/hw/hw3/starter-code/test/simpledb/CatalogTest.java b/hw/hw3/starter-code/test/simpledb/CatalogTest.java
deleted file mode 100644
index 43d058eb3d9bd59bff1883c9e2f1188b21ab6a8a..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/CatalogTest.java
+++ /dev/null
@@ -1,79 +0,0 @@
-package simpledb;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.NoSuchElementException;
-
-import junit.framework.Assert;
-import junit.framework.JUnit4TestAdapter;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import simpledb.TestUtil.SkeletonFile;
-import simpledb.systemtest.SimpleDbTestBase;
-import simpledb.systemtest.SystemTestUtil;
-
-public class CatalogTest extends SimpleDbTestBase {
- private static String name = "test";
- private String nameThisTestRun;
-
- @Before public void addTables() throws Exception {
- Database.getCatalog().clear();
- nameThisTestRun = SystemTestUtil.getUUID();
- Database.getCatalog().addTable(new SkeletonFile(-1, Utility.getTupleDesc(2)), nameThisTestRun);
- Database.getCatalog().addTable(new SkeletonFile(-2, Utility.getTupleDesc(2)), name);
- }
-
- /**
- * Unit test for Catalog.getTupleDesc()
- */
- @Test public void getTupleDesc() throws Exception {
- TupleDesc expected = Utility.getTupleDesc(2);
- TupleDesc actual = Database.getCatalog().getTupleDesc(-1);
-
- assertEquals(expected, actual);
- }
-
- /**
- * Unit test for Catalog.getTableId()
- */
- @Test public void getTableId() {
- assertEquals(-2, Database.getCatalog().getTableId(name));
- assertEquals(-1, Database.getCatalog().getTableId(nameThisTestRun));
-
- try {
- Database.getCatalog().getTableId(null);
- Assert.fail("Should not find table with null name");
- } catch (NoSuchElementException e) {
- // Expected to get here
- }
-
- try {
- Database.getCatalog().getTableId("foo");
- Assert.fail("Should not find table with name foo");
- } catch (NoSuchElementException e) {
- // Expected to get here
- }
- }
-
- /**
- * Unit test for Catalog.getDatabaseFile()
- */
-
- @Test public void getDatabaseFile() throws Exception {
- DbFile f = Database.getCatalog().getDatabaseFile(-1);
-
- // NOTE(ghuo): we try not to dig too deeply into the DbFile API here; we
- // rely on HeapFileTest for that. perform some basic checks.
- assertEquals(-1, f.getId());
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(CatalogTest.class);
- }
-}
-
diff --git a/hw/hw3/starter-code/test/simpledb/FilterTest.java b/hw/hw3/starter-code/test/simpledb/FilterTest.java
deleted file mode 100644
index 153fc374a81141af90f3b3dc4dcb093d4afd93a0..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/FilterTest.java
+++ /dev/null
@@ -1,130 +0,0 @@
-package simpledb;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import junit.framework.JUnit4TestAdapter;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import simpledb.systemtest.SimpleDbTestBase;
-
-public class FilterTest extends SimpleDbTestBase {
-
- int testWidth = 3;
- DbIterator scan;
-
- /**
- * Initialize each unit test
- */
- @Before public void setUp() {
- this.scan = new TestUtil.MockScan(-5, 5, testWidth);
- }
-
- /**
- * Unit test for Filter.getTupleDesc()
- */
- @Test public void getTupleDesc() {
- Predicate pred = new Predicate(0, Predicate.Op.EQUALS, TestUtil.getField(0));
- Filter op = new Filter(pred, scan);
- TupleDesc expected = Utility.getTupleDesc(testWidth);
- TupleDesc actual = op.getTupleDesc();
- assertEquals(expected, actual);
- }
-
- /**
- * Unit test for Filter.rewind()
- */
- @Test public void rewind() throws Exception {
- Predicate pred = new Predicate(0, Predicate.Op.EQUALS, TestUtil.getField(0));
- Filter op = new Filter(pred, scan);
- op.open();
- assertTrue(op.hasNext());
- assertNotNull(op.next());
- assertTrue(TestUtil.checkExhausted(op));
-
- op.rewind();
- Tuple expected = Utility.getHeapTuple(0, testWidth);
- Tuple actual = op.next();
- assertTrue(TestUtil.compareTuples(expected, actual));
- op.close();
- }
-
- /**
- * Unit test for Filter.getNext() using a < predicate that filters
- * some tuples
- */
- @Test public void filterSomeLessThan() throws Exception {
- Predicate pred;
- pred = new Predicate(0, Predicate.Op.LESS_THAN, TestUtil.getField(2));
- Filter op = new Filter(pred, scan);
- TestUtil.MockScan expectedOut = new TestUtil.MockScan(-5, 2, testWidth);
- op.open();
- TestUtil.compareDbIterators(op, expectedOut);
- op.close();
- }
-
- /**
- * Unit test for Filter.getNext() using a < predicate that filters
- * everything
- */
- @Test public void filterAllLessThan() throws Exception {
- Predicate pred;
- pred = new Predicate(0, Predicate.Op.LESS_THAN, TestUtil.getField(-5));
- Filter op = new Filter(pred, scan);
- op.open();
- assertTrue(TestUtil.checkExhausted(op));
- op.close();
- }
-
- /**
- * Unit test for Filter.getNext() using an = predicate
- */
- @Test public void filterEqual() throws Exception {
- Predicate pred;
- this.scan = new TestUtil.MockScan(-5, 5, testWidth);
- pred = new Predicate(0, Predicate.Op.EQUALS, TestUtil.getField(-5));
- Filter op = new Filter(pred, scan);
- op.open();
- assertTrue(TestUtil.compareTuples(Utility.getHeapTuple(-5, testWidth),
- op.next()));
- op.close();
-
- this.scan = new TestUtil.MockScan(-5, 5, testWidth);
- pred = new Predicate(0, Predicate.Op.EQUALS, TestUtil.getField(0));
- op = new Filter(pred, scan);
- op.open();
- assertTrue(TestUtil.compareTuples(Utility.getHeapTuple(0, testWidth),
- op.next()));
- op.close();
-
- this.scan = new TestUtil.MockScan(-5, 5, testWidth);
- pred = new Predicate(0, Predicate.Op.EQUALS, TestUtil.getField(4));
- op = new Filter(pred, scan);
- op.open();
- assertTrue(TestUtil.compareTuples(Utility.getHeapTuple(4, testWidth),
- op.next()));
- op.close();
- }
-
- /**
- * Unit test for Filter.getNext() using an = predicate passing no tuples
- */
- @Test public void filterEqualNoTuples() throws Exception {
- Predicate pred;
- pred = new Predicate(0, Predicate.Op.EQUALS, TestUtil.getField(5));
- Filter op = new Filter(pred, scan);
- op.open();
- TestUtil.checkExhausted(op);
- op.close();
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(FilterTest.class);
- }
-}
-
diff --git a/hw/hw3/starter-code/test/simpledb/HeapFileReadTest.java b/hw/hw3/starter-code/test/simpledb/HeapFileReadTest.java
deleted file mode 100644
index 67df051fa02804c2b086f0dab8433d085c15f325..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/HeapFileReadTest.java
+++ /dev/null
@@ -1,196 +0,0 @@
-package simpledb;
-
-import simpledb.systemtest.SimpleDbTestBase;
-import simpledb.systemtest.SystemTestUtil;
-
-import java.util.*;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.*;
-import junit.framework.JUnit4TestAdapter;
-
-public class HeapFileReadTest extends SimpleDbTestBase {
- private HeapFile hf;
- private TransactionId tid;
- private TupleDesc td;
-
- /**
- * Set up initial resources for each unit test.
- */
- @Before
- public void setUp() throws Exception {
- hf = SystemTestUtil.createRandomHeapFile(2, 20, null, null);
- td = Utility.getTupleDesc(2);
- tid = new TransactionId();
- }
-
- @After
- public void tearDown() throws Exception {
- Database.getBufferPool().transactionComplete(tid);
- }
-
- /**
- * Unit test for HeapFile.getId()
- */
- @Test
- public void getId() throws Exception {
- int id = hf.getId();
-
- // NOTE(ghuo): the value could be anything. test determinism, at least.
- assertEquals(id, hf.getId());
- assertEquals(id, hf.getId());
-
- HeapFile other = SystemTestUtil.createRandomHeapFile(1, 1, null, null);
- assertTrue(id != other.getId());
- }
-
- /**
- * Unit test for HeapFile.getTupleDesc()
- */
- @Test
- public void getTupleDesc() throws Exception {
- assertEquals(td, hf.getTupleDesc());
- }
- /**
- * Unit test for HeapFile.numPages()
- */
- @Test
- public void numPages() throws Exception {
- assertEquals(1, hf.numPages());
- // assertEquals(1, empty.numPages());
- }
-
- /**
- * Unit test for HeapFile.readPage()
- */
- @Test
- public void readPage() throws Exception {
- HeapPageId pid = new HeapPageId(hf.getId(), 0);
- HeapPage page = (HeapPage) hf.readPage(pid);
-
- // NOTE(ghuo): we try not to dig too deeply into the Page API here; we
- // rely on HeapPageTest for that. perform some basic checks.
- assertEquals(484, page.getNumEmptySlots());
- assertTrue(page.isSlotUsed(1));
- assertFalse(page.isSlotUsed(20));
- }
-
- @Test
- public void readFromFileNotMemoryTest() throws Exception {
- ArrayList<ArrayList<Integer>> tuples = new ArrayList<ArrayList<Integer>>(10);
- for (int i = 0; i < 10; ++i) {
- ArrayList<Integer> tuple = new ArrayList<Integer>(2);
- for (int j = 0; j < 2; ++j) {
- tuple.add(0);
- }
- tuples.add(tuple);
- }
- HeapFileEncoder.convert(tuples, hf.getFile(), BufferPool.PAGE_SIZE, 2);
- HeapPageId pid = new HeapPageId(hf.getId(), 0);
- HeapPage page = (HeapPage) hf.readPage(pid);
-
- tuples.clear();
- for (int i = 0; i < 10; ++i) {
- ArrayList<Integer> tuple = new ArrayList<Integer>(2);
- for (int j = 0; j < 2; ++j) {
- tuple.add(1);
- }
- tuples.add(tuple);
- }
- HeapFileEncoder.convert(tuples, hf.getFile(), BufferPool.PAGE_SIZE, 2);
- HeapPageId pid1 = new HeapPageId(hf.getId(), 0);
- HeapPage page1 = (HeapPage) hf.readPage(pid1);
-
- Iterator<Tuple> it = page.iterator();
- Iterator<Tuple> it1 = page1.iterator();
- while (it.hasNext()) {
- Tuple tup = it.next();
- Tuple tup1 = it1.next();
- assertTrue(!tup.toString().equals(tup1.toString()));
- }
- }
-
- @Test
- public void readTwoPages() throws Exception {
- hf = SystemTestUtil.createRandomHeapFile(2, 2000, null, null);
- ArrayList<ArrayList<Integer>> tuples = new ArrayList<ArrayList<Integer>>(10);
- tuples.clear();
- for (int i = 0; i < 2000; ++i) {
- ArrayList<Integer> tuple = new ArrayList<Integer>(2);
- for (int j = 0; j < 2; ++j) {
- if (i == 0)
- tuple.add(0);
- else
- tuple.add(1);
- }
- tuples.add(tuple);
- }
- HeapFileEncoder.convert(tuples, hf.getFile(), BufferPool.PAGE_SIZE, 2);
-
- HeapPageId pid0 = new HeapPageId(hf.getId(), 0);
- HeapPage page0 = (HeapPage) hf.readPage(pid0);
- Iterator<Tuple> it0 = page0.iterator();
- Tuple tup0 = it0.next();
- assertTrue(tup0.getField(0).toString().equals("0"));
-
- HeapPageId pid1 = new HeapPageId(hf.getId(), 1);
- HeapPage page1 = (HeapPage) hf.readPage(pid1);
- Iterator<Tuple> it1 = page1.iterator();
- Tuple tup1 = it1.next();
- assertTrue(tup1.getField(0).toString().equals("1"));
- }
-
- @Test
- public void testIteratorBasic() throws Exception {
- HeapFile smallFile = SystemTestUtil.createRandomHeapFile(2, 3, null,
- null);
-
- DbFileIterator it = smallFile.iterator(tid);
- // Not open yet
- assertFalse(it.hasNext());
- try {
- it.next();
- fail("expected exception");
- } catch (NoSuchElementException e) {
- }
-
- it.open();
- int count = 0;
- while (it.hasNext()) {
- assertNotNull(it.next());
- count += 1;
- }
- assertEquals(3, count);
- it.close();
- }
-
- @Test
- public void testIteratorClose() throws Exception {
- // make more than 1 page. Previous closed iterator would start fetching
- // from page 1.
- HeapFile twoPageFile = SystemTestUtil.createRandomHeapFile(2, 520,
- null, null);
-
- DbFileIterator it = twoPageFile.iterator(tid);
- it.open();
- assertTrue(it.hasNext());
- it.close();
- try {
- it.next();
- fail("expected exception");
- } catch (NoSuchElementException e) {
- }
- // close twice is harmless
- it.close();
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(HeapFileReadTest.class);
- }
-}
diff --git a/hw/hw3/starter-code/test/simpledb/HeapPageIdTest.java b/hw/hw3/starter-code/test/simpledb/HeapPageIdTest.java
deleted file mode 100644
index 4c644211c700e8e75b693ba4386dfade17d063ce..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/HeapPageIdTest.java
+++ /dev/null
@@ -1,86 +0,0 @@
-package simpledb;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import junit.framework.JUnit4TestAdapter;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import simpledb.systemtest.SimpleDbTestBase;
-
-public class HeapPageIdTest extends SimpleDbTestBase {
-
- private HeapPageId pid;
-
- @Before public void createPid() {
- pid = new HeapPageId(1, 1);
- }
-
- /**
- * Unit test for HeapPageId.getTableId()
- */
- @Test public void getTableId() {
- assertEquals(1, pid.getTableId());
- }
-
- /**
- * Unit test for HeapPageId.pageno()
- */
- @Test public void pageno() {
- assertEquals(1, pid.pageNumber());
- }
-
- /**
- * Unit test for HeapPageId.hashCode()
- */
- @Test public void testHashCode() {
- int code1, code2;
-
- // NOTE(ghuo): the hashCode could be anything. test determinism,
- // at least.
- pid = new HeapPageId(1, 1);
- code1 = pid.hashCode();
- assertEquals(code1, pid.hashCode());
- assertEquals(code1, pid.hashCode());
-
- pid = new HeapPageId(2, 2);
- code2 = pid.hashCode();
- assertEquals(code2, pid.hashCode());
- assertEquals(code2, pid.hashCode());
- }
-
- /**
- * Unit test for HeapPageId.equals()
- */
- @Test public void equals() {
- HeapPageId pid1 = new HeapPageId(1, 1);
- HeapPageId pid1Copy = new HeapPageId(1, 1);
- HeapPageId pid2 = new HeapPageId(2, 2);
-
- // .equals() with null should return false
- assertFalse(pid1.equals(null));
-
- // .equals() with the wrong type should return false
- assertFalse(pid1.equals(new Object()));
-
- assertTrue(pid1.equals(pid1));
- assertTrue(pid1.equals(pid1Copy));
- assertTrue(pid1Copy.equals(pid1));
- assertTrue(pid2.equals(pid2));
-
- assertFalse(pid1.equals(pid2));
- assertFalse(pid1Copy.equals(pid2));
- assertFalse(pid2.equals(pid1));
- assertFalse(pid2.equals(pid1Copy));
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(HeapPageIdTest.class);
- }
-}
-
diff --git a/hw/hw3/starter-code/test/simpledb/HeapPageReadTest.java b/hw/hw3/starter-code/test/simpledb/HeapPageReadTest.java
deleted file mode 100644
index fa08d715d8840263a4301bfda28870c9c295d185..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/HeapPageReadTest.java
+++ /dev/null
@@ -1,129 +0,0 @@
-package simpledb;
-
-import simpledb.TestUtil.SkeletonFile;
-import simpledb.systemtest.SimpleDbTestBase;
-import simpledb.systemtest.SystemTestUtil;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.*;
-
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import junit.framework.JUnit4TestAdapter;
-
-public class HeapPageReadTest extends SimpleDbTestBase {
- private HeapPageId pid;
-
- public static final int[][] EXAMPLE_VALUES = new int[][] {
- { 31933, 862 },
- { 29402, 56883 },
- { 1468, 5825 },
- { 17876, 52278 },
- { 6350, 36090 },
- { 34784, 43771 },
- { 28617, 56874 },
- { 19209, 23253 },
- { 56462, 24979 },
- { 51440, 56685 },
- { 3596, 62307 },
- { 45569, 2719 },
- { 22064, 43575 },
- { 42812, 44947 },
- { 22189, 19724 },
- { 33549, 36554 },
- { 9086, 53184 },
- { 42878, 33394 },
- { 62778, 21122 },
- { 17197, 16388 }
- };
-
- public static final byte[] EXAMPLE_DATA;
- static {
- // Build the input table
- ArrayList<ArrayList<Integer>> table = new ArrayList<ArrayList<Integer>>();
- for (int[] tuple : EXAMPLE_VALUES) {
- ArrayList<Integer> listTuple = new ArrayList<Integer>();
- for (int value : tuple) {
- listTuple.add(value);
- }
- table.add(listTuple);
- }
-
- // Convert it to a HeapFile and read in the bytes
- try {
- File temp = File.createTempFile("table", ".dat");
- temp.deleteOnExit();
- HeapFileEncoder.convert(table, temp, BufferPool.getPageSize(), 2);
- EXAMPLE_DATA = TestUtil.readFileBytes(temp.getAbsolutePath());
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- }
-
- /**
- * Set up initial resources for each unit test.
- */
- @Before public void addTable() throws Exception {
- this.pid = new HeapPageId(-1, -1);
- Database.getCatalog().addTable(new SkeletonFile(-1, Utility.getTupleDesc(2)), SystemTestUtil.getUUID());
- }
-
- /**
- * Unit test for HeapPage.getId()
- */
- @Test public void getId() throws Exception {
- HeapPage page = new HeapPage(pid, EXAMPLE_DATA);
- assertEquals(pid, page.getId());
- }
-
- /**
- * Unit test for HeapPage.iterator()
- */
- @Test public void testIterator() throws Exception {
- HeapPage page = new HeapPage(pid, EXAMPLE_DATA);
- Iterator<Tuple> it = page.iterator();
-
- int row = 0;
- while (it.hasNext()) {
- Tuple tup = it.next();
- IntField f0 = (IntField) tup.getField(0);
- IntField f1 = (IntField) tup.getField(1);
-
- assertEquals(EXAMPLE_VALUES[row][0], f0.getValue());
- assertEquals(EXAMPLE_VALUES[row][1], f1.getValue());
- row++;
- }
- }
-
- /**
- * Unit test for HeapPage.getNumEmptySlots()
- */
- @Test public void getNumEmptySlots() throws Exception {
- HeapPage page = new HeapPage(pid, EXAMPLE_DATA);
- assertEquals(484, page.getNumEmptySlots());
- }
-
- /**
- * Unit test for HeapPage.isSlotUsed()
- */
- @Test public void getSlot() throws Exception {
- HeapPage page = new HeapPage(pid, EXAMPLE_DATA);
-
- for (int i = 0; i < 20; ++i)
- assertTrue(page.isSlotUsed(i));
-
- for (int i = 20; i < 504; ++i)
- assertFalse(page.isSlotUsed(i));
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(HeapPageReadTest.class);
- }
-}
diff --git a/hw/hw3/starter-code/test/simpledb/IntegerAggregatorTest.java b/hw/hw3/starter-code/test/simpledb/IntegerAggregatorTest.java
deleted file mode 100644
index 91a932cdcb56d2350081aaad18f0136f1fa9451c..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/IntegerAggregatorTest.java
+++ /dev/null
@@ -1,188 +0,0 @@
-package simpledb;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.NoSuchElementException;
-
-import junit.framework.JUnit4TestAdapter;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import simpledb.systemtest.SimpleDbTestBase;
-
-public class IntegerAggregatorTest extends SimpleDbTestBase {
-
- int width1 = 2;
- DbIterator scan1;
- int[][] sum = null;
- int[][] min = null;
- int[][] max = null;
- int[][] avg = null;
-
- /**
- * Initialize each unit test
- */
- @Before public void createTupleList() throws Exception {
- this.scan1 = TestUtil.createTupleList(width1,
- new int[] { 1, 2,
- 1, 4,
- 1, 6,
- 3, 2,
- 3, 4,
- 3, 6,
- 5, 7 });
-
- // verify how the results progress after a few merges
- this.sum = new int[][] {
- { 1, 2 },
- { 1, 6 },
- { 1, 12 },
- { 1, 12, 3, 2 }
- };
-
- this.min = new int[][] {
- { 1, 2 },
- { 1, 2 },
- { 1, 2 },
- { 1, 2, 3, 2 }
- };
-
- this.max = new int[][] {
- { 1, 2 },
- { 1, 4 },
- { 1, 6 },
- { 1, 6, 3, 2 }
- };
-
- this.avg = new int[][] {
- { 1, 2 },
- { 1, 3 },
- { 1, 4 },
- { 1, 4, 3, 2 }
- };
- }
-
- /**
- * Test IntegerAggregator.mergeTupleIntoGroup() and iterator() over a sum
- */
- @Test public void mergeSum() throws Exception {
- scan1.open();
- IntegerAggregator agg = new IntegerAggregator(0, Type.INT_TYPE, 1, Aggregator.Op.SUM);
-
- for (int[] step : sum) {
- agg.mergeTupleIntoGroup(scan1.next());
- DbIterator it = agg.iterator();
- it.open();
- TestUtil.matchAllTuples(TestUtil.createTupleList(width1, step), it);
- }
- }
-
- /**
- * Test IntegerAggregator.mergeTupleIntoGroup() and iterator() over a min
- */
- @Test public void mergeMin() throws Exception {
- scan1.open();
- IntegerAggregator agg = new IntegerAggregator(0,Type.INT_TYPE, 1, Aggregator.Op.MIN);
-
- DbIterator it;
- for (int[] step : min) {
- agg.mergeTupleIntoGroup(scan1.next());
- it = agg.iterator();
- it.open();
- TestUtil.matchAllTuples(TestUtil.createTupleList(width1, step), it);
- }
- }
-
- /**
- * Test IntegerAggregator.mergeTupleIntoGroup() and iterator() over a max
- */
- @Test public void mergeMax() throws Exception {
- scan1.open();
- IntegerAggregator agg = new IntegerAggregator(0, Type.INT_TYPE, 1, Aggregator.Op.MAX);
-
- DbIterator it;
- for (int[] step : max) {
- agg.mergeTupleIntoGroup(scan1.next());
- it = agg.iterator();
- it.open();
- TestUtil.matchAllTuples(TestUtil.createTupleList(width1, step), it);
- }
- }
-
- /**
- * Test IntegerAggregator.mergeTupleIntoGroup() and iterator() over an avg
- */
- @Test public void mergeAvg() throws Exception {
- scan1.open();
- IntegerAggregator agg = new IntegerAggregator(0, Type.INT_TYPE, 1, Aggregator.Op.AVG);
-
- DbIterator it;
- for (int[] step : avg) {
- agg.mergeTupleIntoGroup(scan1.next());
- it = agg.iterator();
- it.open();
- TestUtil.matchAllTuples(TestUtil.createTupleList(width1, step), it);
- }
- }
-
- /**
- * Test IntegerAggregator.iterator() for DbIterator behaviour
- */
- @Test public void testIterator() throws Exception {
- // first, populate the aggregator via sum over scan1
- scan1.open();
- IntegerAggregator agg = new IntegerAggregator(0, Type.INT_TYPE, 1, Aggregator.Op.SUM);
- try {
- while (true)
- agg.mergeTupleIntoGroup(scan1.next());
- } catch (NoSuchElementException e) {
- // explicitly ignored
- }
-
- DbIterator it = agg.iterator();
- it.open();
-
- // verify it has three elements
- int count = 0;
- try {
- while (true) {
- it.next();
- count++;
- }
- } catch (NoSuchElementException e) {
- // explicitly ignored
- }
- assertEquals(3, count);
-
- // rewind and try again
- it.rewind();
- count = 0;
- try {
- while (true) {
- it.next();
- count++;
- }
- } catch (NoSuchElementException e) {
- // explicitly ignored
- }
- assertEquals(3, count);
-
- // close it and check that we don't get anything
- it.close();
- try {
- it.next();
- throw new Exception("IntegerAggregator iterator yielded tuple after close");
- } catch (Exception e) {
- // explicitly ignored
- }
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(IntegerAggregatorTest.class);
- }
-}
-
diff --git a/hw/hw3/starter-code/test/simpledb/JoinPredicateTest.java b/hw/hw3/starter-code/test/simpledb/JoinPredicateTest.java
deleted file mode 100644
index 1f11322d5fb1714421290812ca56b5dc1de5d415..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/JoinPredicateTest.java
+++ /dev/null
@@ -1,66 +0,0 @@
-package simpledb;
-
-import org.junit.Test;
-
-import simpledb.systemtest.SimpleDbTestBase;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.assertFalse;
-import junit.framework.JUnit4TestAdapter;
-
-public class JoinPredicateTest extends SimpleDbTestBase {
-
- /**
- * Unit test for JoinPredicate.filter()
- */
- @Test public void filterVaryingVals() {
- int[] vals = new int[] { -1, 0, 1 };
-
- for (int i : vals) {
- JoinPredicate p = new JoinPredicate(0,
- Predicate.Op.EQUALS, 0);
- assertFalse(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i - 1)));
- assertTrue(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i)));
- assertFalse(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i + 1)));
- }
-
- for (int i : vals) {
- JoinPredicate p = new JoinPredicate(0,
- Predicate.Op.GREATER_THAN, 0);
- assertTrue(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i - 1)));
- assertFalse(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i)));
- assertFalse(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i + 1)));
- }
-
- for (int i : vals) {
- JoinPredicate p = new JoinPredicate(0,
- Predicate.Op.GREATER_THAN_OR_EQ, 0);
- assertTrue(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i - 1)));
- assertTrue(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i)));
- assertFalse(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i + 1)));
- }
-
- for (int i : vals) {
- JoinPredicate p = new JoinPredicate(0,
- Predicate.Op.LESS_THAN, 0);
- assertFalse(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i - 1)));
- assertFalse(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i)));
- assertTrue(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i + 1)));
- }
-
- for (int i : vals) {
- JoinPredicate p = new JoinPredicate(0,
- Predicate.Op.LESS_THAN_OR_EQ, 0);
- assertFalse(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i - 1)));
- assertTrue(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i)));
- assertTrue(p.filter(Utility.getHeapTuple(i), Utility.getHeapTuple(i + 1)));
- }
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(JoinPredicateTest.class);
- }
-}
-
diff --git a/hw/hw3/starter-code/test/simpledb/JoinTest.java b/hw/hw3/starter-code/test/simpledb/JoinTest.java
deleted file mode 100644
index 9c406c92278ff3d90bb408a0cd530ff610475c52..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/JoinTest.java
+++ /dev/null
@@ -1,115 +0,0 @@
-package simpledb;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-import junit.framework.JUnit4TestAdapter;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import simpledb.systemtest.SimpleDbTestBase;
-
-public class JoinTest extends SimpleDbTestBase {
-
- int width1 = 2;
- int width2 = 3;
- DbIterator scan1;
- DbIterator scan2;
- DbIterator eqJoin;
- DbIterator gtJoin;
-
- /**
- * Initialize each unit test
- */
- @Before public void createTupleLists() throws Exception {
- this.scan1 = TestUtil.createTupleList(width1,
- new int[] { 1, 2,
- 3, 4,
- 5, 6,
- 7, 8 });
- this.scan2 = TestUtil.createTupleList(width2,
- new int[] { 1, 2, 3,
- 2, 3, 4,
- 3, 4, 5,
- 4, 5, 6,
- 5, 6, 7 });
- this.eqJoin = TestUtil.createTupleList(width1 + width2,
- new int[] { 1, 2, 1, 2, 3,
- 3, 4, 3, 4, 5,
- 5, 6, 5, 6, 7 });
- this.gtJoin = TestUtil.createTupleList(width1 + width2,
- new int[] {
- 3, 4, 1, 2, 3, // 1, 2 < 3
- 3, 4, 2, 3, 4,
- 5, 6, 1, 2, 3, // 1, 2, 3, 4 < 5
- 5, 6, 2, 3, 4,
- 5, 6, 3, 4, 5,
- 5, 6, 4, 5, 6,
- 7, 8, 1, 2, 3, // 1, 2, 3, 4, 5 < 7
- 7, 8, 2, 3, 4,
- 7, 8, 3, 4, 5,
- 7, 8, 4, 5, 6,
- 7, 8, 5, 6, 7 });
- }
-
- /**
- * Unit test for Join.getTupleDesc()
- */
- @Test public void getTupleDesc() {
- JoinPredicate pred = new JoinPredicate(0, Predicate.Op.EQUALS, 0);
- Join op = new Join(pred, scan1, scan2);
- TupleDesc expected = Utility.getTupleDesc(width1 + width2);
- TupleDesc actual = op.getTupleDesc();
- assertEquals(expected, actual);
- }
-
- /**
- * Unit test for Join.rewind()
- */
- @Test public void rewind() throws Exception {
- JoinPredicate pred = new JoinPredicate(0, Predicate.Op.EQUALS, 0);
- Join op = new Join(pred, scan1, scan2);
- op.open();
- while (op.hasNext()) {
- assertNotNull(op.next());
- }
- assertTrue(TestUtil.checkExhausted(op));
- op.rewind();
-
- eqJoin.open();
- Tuple expected = eqJoin.next();
- Tuple actual = op.next();
- assertTrue(TestUtil.compareTuples(expected, actual));
- }
-
- /**
- * Unit test for Join.getNext() using a > predicate
- */
- @Test public void gtJoin() throws Exception {
- JoinPredicate pred = new JoinPredicate(0, Predicate.Op.GREATER_THAN, 0);
- Join op = new Join(pred, scan1, scan2);
- op.open();
- gtJoin.open();
- TestUtil.matchAllTuples(gtJoin, op);
- }
-
- /**
- * Unit test for Join.getNext() using an = predicate
- */
- @Test public void eqJoin() throws Exception {
- JoinPredicate pred = new JoinPredicate(0, Predicate.Op.EQUALS, 0);
- Join op = new Join(pred, scan1, scan2);
- op.open();
- eqJoin.open();
- TestUtil.matchAllTuples(eqJoin, op);
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(JoinTest.class);
- }
-}
-
diff --git a/hw/hw3/starter-code/test/simpledb/PredicateTest.java b/hw/hw3/starter-code/test/simpledb/PredicateTest.java
deleted file mode 100644
index bbacf79a3758a45bc947f7f1c41a06acb09cbe5d..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/PredicateTest.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package simpledb;
-
-import org.junit.Test;
-
-import simpledb.systemtest.SimpleDbTestBase;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.assertFalse;
-import junit.framework.JUnit4TestAdapter;
-
-public class PredicateTest extends SimpleDbTestBase{
-
- /**
- * Unit test for Predicate.filter()
- */
- @Test public void filter() {
- int[] vals = new int[] { -1, 0, 1 };
-
- for (int i : vals) {
- Predicate p = new Predicate(0, Predicate.Op.EQUALS, TestUtil.getField(i));
- assertFalse(p.filter(Utility.getHeapTuple(i - 1)));
- assertTrue(p.filter(Utility.getHeapTuple(i)));
- assertFalse(p.filter(Utility.getHeapTuple(i + 1)));
- }
-
- for (int i : vals) {
- Predicate p = new Predicate(0, Predicate.Op.GREATER_THAN,
- TestUtil.getField(i));
- assertFalse(p.filter(Utility.getHeapTuple(i - 1)));
- assertFalse(p.filter(Utility.getHeapTuple(i)));
- assertTrue(p.filter(Utility.getHeapTuple(i + 1)));
- }
-
- for (int i : vals) {
- Predicate p = new Predicate(0, Predicate.Op.GREATER_THAN_OR_EQ,
- TestUtil.getField(i));
- assertFalse(p.filter(Utility.getHeapTuple(i - 1)));
- assertTrue(p.filter(Utility.getHeapTuple(i)));
- assertTrue(p.filter(Utility.getHeapTuple(i + 1)));
- }
-
- for (int i : vals) {
- Predicate p = new Predicate(0, Predicate.Op.LESS_THAN,
- TestUtil.getField(i));
- assertTrue(p.filter(Utility.getHeapTuple(i - 1)));
- assertFalse(p.filter(Utility.getHeapTuple(i)));
- assertFalse(p.filter(Utility.getHeapTuple(i + 1)));
- }
-
- for (int i : vals) {
- Predicate p = new Predicate(0, Predicate.Op.LESS_THAN_OR_EQ,
- TestUtil.getField(i));
- assertTrue(p.filter(Utility.getHeapTuple(i - 1)));
- assertTrue(p.filter(Utility.getHeapTuple(i)));
- assertFalse(p.filter(Utility.getHeapTuple(i + 1)));
- }
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(PredicateTest.class);
- }
-}
-
diff --git a/hw/hw3/starter-code/test/simpledb/RecordIdTest.java b/hw/hw3/starter-code/test/simpledb/RecordIdTest.java
deleted file mode 100644
index 660655153577ffb1f459a0d0c7868383c94e5b04..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/RecordIdTest.java
+++ /dev/null
@@ -1,72 +0,0 @@
-package simpledb;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import junit.framework.JUnit4TestAdapter;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import simpledb.systemtest.SimpleDbTestBase;
-
-public class RecordIdTest extends SimpleDbTestBase {
-
- private static RecordId hrid;
- private static RecordId hrid2;
- private static RecordId hrid3;
- private static RecordId hrid4;
-
- @Before public void createPids() {
- HeapPageId hpid = new HeapPageId(-1, 2);
- HeapPageId hpid2 = new HeapPageId(-1, 2);
- HeapPageId hpid3 = new HeapPageId(-2, 2);
- hrid = new RecordId(hpid, 3);
- hrid2 = new RecordId(hpid2, 3);
- hrid3 = new RecordId(hpid, 4);
- hrid4 = new RecordId(hpid3, 3);
-
- }
-
- /**
- * Unit test for RecordId.getPageId()
- */
- @Test public void getPageId() {
- HeapPageId hpid = new HeapPageId(-1, 2);
- assertEquals(hpid, hrid.getPageId());
-
- }
-
- /**
- * Unit test for RecordId.tupleno()
- */
- @Test public void tupleno() {
- assertEquals(3, hrid.tupleno());
- }
-
- /**
- * Unit test for RecordId.equals()
- */
- @Test public void equals() {
- assertEquals(hrid, hrid2);
- assertEquals(hrid2, hrid);
- assertFalse(hrid.equals(hrid3));
- assertFalse(hrid3.equals(hrid));
- assertFalse(hrid2.equals(hrid4));
- assertFalse(hrid4.equals(hrid2));
- }
-
- /**
- * Unit test for RecordId.hashCode()
- */
- @Test public void hCode() {
- assertEquals(hrid.hashCode(), hrid2.hashCode());
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(RecordIdTest.class);
- }
-}
-
diff --git a/hw/hw3/starter-code/test/simpledb/StringAggregatorTest.java b/hw/hw3/starter-code/test/simpledb/StringAggregatorTest.java
deleted file mode 100644
index 9615236d3e4e902a77c6331b168dd098eaa3b01d..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/StringAggregatorTest.java
+++ /dev/null
@@ -1,115 +0,0 @@
-package simpledb;
-
-import java.util.*;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import simpledb.systemtest.SimpleDbTestBase;
-import static org.junit.Assert.assertEquals;
-import junit.framework.JUnit4TestAdapter;
-
-public class StringAggregatorTest extends SimpleDbTestBase {
-
- int width1 = 2;
- DbIterator scan1;
- int[][] count = null;
-
- /**
- * Initialize each unit test
- */
- @Before public void createTupleList() throws Exception {
- this.scan1 = TestUtil.createTupleList(width1,
- new Object[] { 1, "a",
- 1, "b",
- 1, "c",
- 3, "d",
- 3, "e",
- 3, "f",
- 5, "g" });
-
- // verify how the results progress after a few merges
- this.count = new int[][] {
- { 1, 1 },
- { 1, 2 },
- { 1, 3 },
- { 1, 3, 3, 1 }
- };
-
- }
-
- /**
- * Test String.mergeTupleIntoGroup() and iterator() over a COUNT
- */
- @Test public void mergeCount() throws Exception {
- scan1.open();
- StringAggregator agg = new StringAggregator(0, Type.INT_TYPE, 1, Aggregator.Op.COUNT);
-
- for (int[] step : count) {
- agg.mergeTupleIntoGroup(scan1.next());
- DbIterator it = agg.iterator();
- it.open();
- TestUtil.matchAllTuples(TestUtil.createTupleList(width1, step), it);
- }
- }
-
- /**
- * Test StringAggregator.iterator() for DbIterator behaviour
- */
- @Test public void testIterator() throws Exception {
- // first, populate the aggregator via sum over scan1
- scan1.open();
- StringAggregator agg = new StringAggregator(0, Type.INT_TYPE, 1, Aggregator.Op.COUNT);
- try {
- while (true)
- agg.mergeTupleIntoGroup(scan1.next());
- } catch (NoSuchElementException e) {
- // explicitly ignored
- }
-
- DbIterator it = agg.iterator();
- it.open();
-
- // verify it has three elements
- int count = 0;
- try {
- while (true) {
- it.next();
- count++;
- }
- } catch (NoSuchElementException e) {
- // explicitly ignored
- }
- assertEquals(3, count);
-
- // rewind and try again
- it.rewind();
- count = 0;
- try {
- while (true) {
- it.next();
- count++;
- }
- } catch (NoSuchElementException e) {
- // explicitly ignored
- }
- assertEquals(3, count);
-
- // close it and check that we don't get anything
- it.close();
- try {
- it.next();
- throw new Exception("StringAggreator iterator yielded tuple after close");
- } catch (Exception e) {
- // explicitly ignored
- }
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(StringAggregatorTest.class);
- }
-}
-
diff --git a/hw/hw3/starter-code/test/simpledb/TestUtil.java b/hw/hw3/starter-code/test/simpledb/TestUtil.java
deleted file mode 100644
index 48c75856e190ad90db760ee1e75f28f6c23e18cc..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/TestUtil.java
+++ /dev/null
@@ -1,396 +0,0 @@
-package simpledb;
-
-import java.io.*;
-import java.util.*;
-
-import static org.junit.Assert.*;
-
-public class TestUtil {
- /**
- * @return an IntField with value n
- */
- public static Field getField(int n) {
- return new IntField(n);
- }
-
- /**
- * @return a DbIterator over a list of tuples constructed over the data
- * provided in the constructor. This iterator is already open.
- * @param width the number of fields in each tuple
- * @param tupdata an array such that the ith element the jth tuple lives
- * in slot j * width + i
- * @require tupdata.length % width == 0
- * @throws DbException if we encounter an error creating the
- * TupleIterator
- */
- public static TupleIterator createTupleList(int width, int[] tupdata) {
- int i = 0;
- ArrayList<Tuple> tuplist = new ArrayList<Tuple>();
- while (i < tupdata.length) {
- Tuple tup = new Tuple(Utility.getTupleDesc(width));
- for (int j = 0; j < width; ++j)
- tup.setField(j, getField(tupdata[i++]));
- tuplist.add(tup);
- }
-
- TupleIterator result = new TupleIterator(Utility.getTupleDesc(width), tuplist);
- result.open();
- return result;
- }
-
- /**
- * @return a DbIterator over a list of tuples constructed over the data
- * provided in the constructor. This iterator is already open.
- * @param width the number of fields in each tuple
- * @param tupdata an array such that the ith element the jth tuple lives
- * in slot j * width + i. Objects can be strings or ints; tuples must all be of same type.
- * @require tupdata.length % width == 0
- * @throws DbException if we encounter an error creating the
- * TupleIterator
- */
- public static TupleIterator createTupleList(int width, Object[] tupdata) {
- ArrayList<Tuple> tuplist = new ArrayList<Tuple>();
- TupleDesc td;
- Type[] types = new Type[width];
- int i= 0;
- for (int j = 0; j < width; j++) {
- if (tupdata[j] instanceof String) {
- types[j] = Type.STRING_TYPE;
- }
- if (tupdata[j] instanceof Integer) {
- types[j] = Type.INT_TYPE;
- }
- }
- td = new TupleDesc(types);
-
- while (i < tupdata.length) {
- Tuple tup = new Tuple(td);
- for (int j = 0; j < width; j++) {
- Field f;
- Object t = tupdata[i++];
- if (t instanceof String)
- f = new StringField((String)t, Type.STRING_LEN);
- else
- f = new IntField((Integer)t);
-
- tup.setField(j, f);
- }
- tuplist.add(tup);
- }
-
- TupleIterator result = new TupleIterator(td, tuplist);
- result.open();
- return result;
- }
-
- /**
- * @return true iff the tuples have the same number of fields and
- * corresponding fields in the two Tuples are all equal.
- */
- public static boolean compareTuples(Tuple t1, Tuple t2) {
- if (t1.getTupleDesc().numFields() != t2.getTupleDesc().numFields())
- return false;
-
- for (int i = 0; i < t1.getTupleDesc().numFields(); ++i) {
- if (!(t1.getTupleDesc().getFieldType(i).equals(t2.getTupleDesc().getFieldType(i))))
- return false;
- if (!(t1.getField(i).equals(t2.getField(i))))
- return false;
- }
-
- return true;
- }
-
- /**
- * Check to see if the DbIterators have the same number of tuples and
- * each tuple pair in parallel iteration satisfies compareTuples .
- * If not, throw an assertion.
- */
- public static void compareDbIterators(DbIterator expected, DbIterator actual)
- throws DbException, TransactionAbortedException {
- while (expected.hasNext()) {
- assertTrue(actual.hasNext());
-
- Tuple expectedTup = expected.next();
- Tuple actualTup = actual.next();
- assertTrue(compareTuples(expectedTup, actualTup));
- }
- // Both must now be exhausted
- assertFalse(expected.hasNext());
- assertFalse(actual.hasNext());
- }
-
- /**
- * Check to see if every tuple in expected matches <b>some</b> tuple
- * in actual via compareTuples. Note that actual may be a superset.
- * If not, throw an assertion.
- */
- public static void matchAllTuples(DbIterator expected, DbIterator actual) throws
- DbException, TransactionAbortedException {
- // TODO(ghuo): this n^2 set comparison is kind of dumb, but we haven't
- // implemented hashCode or equals for tuples.
- boolean matched = false;
- while (expected.hasNext()) {
- Tuple expectedTup = expected.next();
- matched = false;
- actual.rewind();
-
- while (actual.hasNext()) {
- Tuple next = actual.next();
- if (compareTuples(expectedTup, next)) {
- matched = true;
- break;
- }
- }
-
- if (!matched) {
- throw new RuntimeException("expected tuple not found: " + expectedTup);
- }
- }
- }
-
- /**
- * Verifies that the DbIterator has been exhausted of all elements.
- */
- public static boolean checkExhausted(DbIterator it)
- throws TransactionAbortedException, DbException {
-
- if (it.hasNext()) return false;
-
- try {
- Tuple t = it.next();
- System.out.println("Got unexpected tuple: " + t);
- return false;
- } catch (NoSuchElementException e) {
- return true;
- }
- }
-
- /**
- * @return a byte array containing the contents of the file 'path'
- */
- public static byte[] readFileBytes(String path) throws IOException {
- File f = new File(path);
- InputStream is = new FileInputStream(f);
- byte[] buf = new byte[(int) f.length()];
-
- int offset = 0;
- int count = 0;
- while (offset < buf.length
- && (count = is.read(buf, offset, buf.length - offset)) >= 0) {
- offset += count;
- }
-
- // check that we grabbed the entire file
- if (offset < buf.length)
- throw new IOException("failed to read test data");
-
- // Close the input stream and return bytes
- is.close();
- return buf;
- }
-
- /**
- * Stub DbFile class for unit testing.
- */
- public static class SkeletonFile implements DbFile {
- private int tableid;
- private TupleDesc td;
-
- public SkeletonFile(int tableid, TupleDesc td) {
- this.tableid = tableid;
- this.td = td;
- }
-
- public Page readPage(PageId id) throws NoSuchElementException {
- throw new RuntimeException("not implemented");
- }
-
- public int numPages() {
- throw new RuntimeException("not implemented");
- }
-
- public void writePage(Page p) throws IOException {
- throw new RuntimeException("not implemented");
- }
-
- public ArrayList<Page> insertTuple(TransactionId tid, Tuple t)
- throws DbException, IOException, TransactionAbortedException {
- throw new RuntimeException("not implemented");
- }
-
- public ArrayList<Page> deleteTuple(TransactionId tid, Tuple t)
- throws DbException, TransactionAbortedException {
- throw new RuntimeException("not implemented");
- }
-
- public int bytesPerPage() {
- throw new RuntimeException("not implemented");
- }
-
- public int getId() {
- return tableid;
- }
-
- public DbFileIterator iterator(TransactionId tid) {
- throw new RuntimeException("not implemented");
- }
-
- public TupleDesc getTupleDesc() {
- return td;
- }
- }
-
- /**
- * Mock SeqScan class for unit testing.
- */
- public static class MockScan implements DbIterator {
- private int cur, low, high, width;
-
- /**
- * Creates a fake SeqScan that returns tuples sequentially with 'width'
- * fields, each with the same value, that increases from low (inclusive)
- * and high (exclusive) over getNext calls.
- */
- public MockScan(int low, int high, int width) {
- this.low = low;
- this.high = high;
- this.width = width;
- this.cur = low;
- }
-
- public void open() {
- }
-
- public void close() {
- }
-
- public void rewind() {
- cur = low;
- }
-
- public TupleDesc getTupleDesc() {
- return Utility.getTupleDesc(width);
- }
-
- protected Tuple readNext() {
- if (cur >= high) return null;
-
- Tuple tup = new Tuple(getTupleDesc());
- for (int i = 0; i < width; ++i)
- tup.setField(i, new IntField(cur));
- cur++;
- return tup;
- }
-
- public boolean hasNext() throws DbException, TransactionAbortedException {
- if (cur >= high) return false;
- return true;
- }
-
- public Tuple next() throws DbException, TransactionAbortedException, NoSuchElementException {
- if(cur >= high) throw new NoSuchElementException();
- Tuple tup = new Tuple(getTupleDesc());
- for (int i = 0; i < width; ++i)
- tup.setField(i, new IntField(cur));
- cur++;
- return tup;
- }
- }
-
- /**
- * Helper class that attempts to acquire a lock on a given page in a new
- * thread.
- *
- * @return a handle to the Thread that will attempt lock acquisition after it
- * has been started
- */
- static class LockGrabber extends Thread {
-
- TransactionId tid;
- PageId pid;
- Permissions perm;
- boolean acquired;
- Exception error;
- Object alock;
- Object elock;
-
- /**
- * @param tid the transaction on whose behalf we want to acquire the lock
- * @param pid the page over which we want to acquire the lock
- * @param perm the desired lock permissions
- */
- public LockGrabber(TransactionId tid, PageId pid, Permissions perm) {
- this.tid = tid;
- this.pid = pid;
- this.perm = perm;
- this.acquired = false;
- this.error = null;
- this.alock = new Object();
- this.elock = new Object();
- }
-
- public void run() {
- try {
- Database.getBufferPool().getPage(tid, pid, perm);
- synchronized(alock) {
- acquired = true;
- }
- } catch (Exception e) {
- e.printStackTrace();
- synchronized(elock) {
- error = e;
- }
-
- try {
- Database.getBufferPool().transactionComplete(tid, false);
- } catch (java.io.IOException e2) {
- e2.printStackTrace();
- }
- }
- }
-
- /**
- * @return true if we successfully acquired the specified lock
- */
- public boolean acquired() {
- synchronized(alock) {
- return acquired;
- }
- }
-
- /**
- * @return an Exception instance if one occured during lock acquisition;
- * null otherwise
- */
- public Exception getError() {
- synchronized(elock) {
- return error;
- }
- }
- }
-
- /** JUnit fixture that creates a heap file and cleans it up afterward. */
- public static abstract class CreateHeapFile {
- protected CreateHeapFile() {
- try{
- emptyFile = File.createTempFile("empty", ".dat");
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- emptyFile.deleteOnExit();
- }
-
- protected void setUp() throws Exception {
- try{
- Database.reset();
- empty = Utility.createEmptyHeapFile(emptyFile.getAbsolutePath(), 2);
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- }
-
- protected HeapFile empty;
- private final File emptyFile;
- }
-}
diff --git a/hw/hw3/starter-code/test/simpledb/TupleDescTest.java b/hw/hw3/starter-code/test/simpledb/TupleDescTest.java
deleted file mode 100644
index 1cbe39601908e59495e68ac47160af10adfb9b9b..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/TupleDescTest.java
+++ /dev/null
@@ -1,177 +0,0 @@
-package simpledb;
-
-import java.util.NoSuchElementException;
-
-import org.junit.Test;
-
-import simpledb.systemtest.SimpleDbTestBase;
-
-import static org.junit.Assert.*;
-import junit.framework.Assert;
-import junit.framework.JUnit4TestAdapter;
-
-public class TupleDescTest extends SimpleDbTestBase {
-
- /**
- * Unit test for TupleDesc.combine()
- */
- @Test public void combine() {
- TupleDesc td1, td2, td3;
-
- td1 = Utility.getTupleDesc(1, "td1");
- td2 = Utility.getTupleDesc(2, "td2");
-
- // test td1.combine(td2)
- td3 = TupleDesc.merge(td1, td2);
- assertEquals(3 , td3.numFields());
- assertEquals(3 * Type.INT_TYPE.getLen(), td3.getSize());
- for (int i = 0; i < 3; ++i)
- assertEquals(Type.INT_TYPE, td3.getFieldType(i));
- assertEquals(combinedStringArrays(td1, td2, td3), true);
-
- // test td2.combine(td1)
- td3 = TupleDesc.merge(td2, td1);
- assertEquals(3 , td3.numFields());
- assertEquals(3 * Type.INT_TYPE.getLen(), td3.getSize());
- for (int i = 0; i < 3; ++i)
- assertEquals(Type.INT_TYPE, td3.getFieldType(i));
- assertEquals(combinedStringArrays(td2, td1, td3), true);
-
- // test td2.combine(td2)
- td3 = TupleDesc.merge(td2, td2);
- assertEquals(4 , td3.numFields());
- assertEquals(4 * Type.INT_TYPE.getLen(), td3.getSize());
- for (int i = 0; i < 4; ++i)
- assertEquals(Type.INT_TYPE, td3.getFieldType(i));
- assertEquals(combinedStringArrays(td2, td2, td3), true);
- }
-
- /**
- * Ensures that combined's field names = td1's field names + td2's field names
- */
- private boolean combinedStringArrays(TupleDesc td1, TupleDesc td2, TupleDesc combined) {
- for (int i = 0; i < td1.numFields(); i++) {
- if (!(((td1.getFieldName(i) == null) && (combined.getFieldName(i) == null)) ||
- td1.getFieldName(i).equals(combined.getFieldName(i)))) {
- return false;
- }
- }
-
- for (int i = td1.numFields(); i < td1.numFields() + td2.numFields(); i++) {
- if (!(((td2.getFieldName(i-td1.numFields()) == null) && (combined.getFieldName(i) == null)) ||
- td2.getFieldName(i-td1.numFields()).equals(combined.getFieldName(i)))) {
- return false;
- }
- }
-
- return true;
- }
-
- /**
- * Unit test for TupleDesc.getType()
- */
- @Test public void getType() {
- int[] lengths = new int[] { 1, 2, 1000 };
-
- for (int len: lengths) {
- TupleDesc td = Utility.getTupleDesc(len);
- for (int i = 0; i < len; ++i)
- assertEquals(Type.INT_TYPE, td.getFieldType(i));
- }
- }
-
- /**
- * Unit test for TupleDesc.nameToId()
- */
- @Test public void nameToId() {
- int[] lengths = new int[] { 1, 2, 1000 };
- String prefix = "test";
-
- for (int len: lengths) {
- // Make sure you retrieve well-named fields
- TupleDesc td = Utility.getTupleDesc(len, prefix);
- for (int i = 0; i < len; ++i) {
- assertEquals(i, td.fieldNameToIndex(prefix + i));
- }
-
- // Make sure you throw exception for non-existent fields
- try {
- td.fieldNameToIndex("foo");
- Assert.fail("foo is not a valid field name");
- } catch (NoSuchElementException e) {
- // expected to get here
- }
-
- // Make sure you throw exception for null searches
- try {
- td.fieldNameToIndex(null);
- Assert.fail("null is not a valid field name");
- } catch (NoSuchElementException e) {
- // expected to get here
- }
-
- // Make sure you throw exception when all field names are null
- td = Utility.getTupleDesc(len);
- try {
- td.fieldNameToIndex(prefix);
- Assert.fail("no fields are named, so you can't find it");
- } catch (NoSuchElementException e) {
- // expected to get here
- }
- }
- }
-
- /**
- * Unit test for TupleDesc.getSize()
- */
- @Test public void getSize() {
- int[] lengths = new int[] { 1, 2, 1000 };
-
- for (int len: lengths) {
- TupleDesc td = Utility.getTupleDesc(len);
- assertEquals(len * Type.INT_TYPE.getLen(), td.getSize());
- }
- }
-
- /**
- * Unit test for TupleDesc.numFields()
- */
- @Test public void numFields() {
- int[] lengths = new int[] { 1, 2, 1000 };
-
- for (int len : lengths) {
- TupleDesc td = Utility.getTupleDesc(len);
- assertEquals(len, td.numFields());
- }
- }
-
- @Test public void testEquals() {
- TupleDesc singleInt = new TupleDesc(new Type[]{Type.INT_TYPE});
- TupleDesc singleInt2 = new TupleDesc(new Type[]{Type.INT_TYPE});
- TupleDesc intString = new TupleDesc(new Type[]{Type.INT_TYPE, Type.STRING_TYPE});
-
- // .equals() with null should return false
- assertFalse(singleInt.equals(null));
-
- // .equals() with the wrong type should return false
- assertFalse(singleInt.equals(new Object()));
-
- assertTrue(singleInt.equals(singleInt));
- assertTrue(singleInt.equals(singleInt2));
- assertTrue(singleInt2.equals(singleInt));
- assertTrue(intString.equals(intString));
-
- assertFalse(singleInt.equals(intString));
- assertFalse(singleInt2.equals(intString));
- assertFalse(intString.equals(singleInt));
- assertFalse(intString.equals(singleInt2));
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(TupleDescTest.class);
- }
-}
-
diff --git a/hw/hw3/starter-code/test/simpledb/TupleTest.java b/hw/hw3/starter-code/test/simpledb/TupleTest.java
deleted file mode 100644
index e3bf6aef057041c7ba22104a5b55aecbbbd99512..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/TupleTest.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package simpledb;
-
-import static org.junit.Assert.assertEquals;
-import junit.framework.JUnit4TestAdapter;
-
-import org.junit.Test;
-
-import simpledb.systemtest.SimpleDbTestBase;
-
-public class TupleTest extends SimpleDbTestBase {
-
- /**
- * Unit test for Tuple.getField() and Tuple.setField()
- */
- @Test public void modifyFields() {
- TupleDesc td = Utility.getTupleDesc(2);
-
- Tuple tup = new Tuple(td);
- tup.setField(0, new IntField(-1));
- tup.setField(1, new IntField(0));
-
- assertEquals(new IntField(-1), tup.getField(0));
- assertEquals(new IntField(0), tup.getField(1));
-
- tup.setField(0, new IntField(1));
- tup.setField(1, new IntField(37));
-
- assertEquals(new IntField(1), tup.getField(0));
- assertEquals(new IntField(37), tup.getField(1));
- }
-
- /**
- * Unit test for Tuple.getTupleDesc()
- */
- @Test public void getTupleDesc() {
- TupleDesc td = Utility.getTupleDesc(5);
- Tuple tup = new Tuple(td);
- assertEquals(td, tup.getTupleDesc());
- }
-
- /**
- * Unit test for Tuple.getRecordId() and Tuple.setRecordId()
- */
- @Test public void modifyRecordId() {
- Tuple tup1 = new Tuple(Utility.getTupleDesc(1));
- HeapPageId pid1 = new HeapPageId(0,0);
- RecordId rid1 = new RecordId(pid1, 0);
- tup1.setRecordId(rid1);
-
- try {
- assertEquals(rid1, tup1.getRecordId());
- } catch (java.lang.UnsupportedOperationException e) {
- //rethrow the exception with an explanation
- throw new UnsupportedOperationException("modifyRecordId() test failed due to " +
- "RecordId.equals() not being implemented. This is not required for Lab 1, " +
- "but should pass when you do implement the RecordId class.");
- }
- }
-
- /**
- * JUnit suite target
- */
- public static junit.framework.Test suite() {
- return new JUnit4TestAdapter(TupleTest.class);
- }
-}
-
diff --git a/hw/hw3/starter-code/test/simpledb/systemtest/AggregateTest.java b/hw/hw3/starter-code/test/simpledb/systemtest/AggregateTest.java
deleted file mode 100644
index 39cd9763cd9b3dd5dced87af40717b8d23974e49..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/systemtest/AggregateTest.java
+++ /dev/null
@@ -1,120 +0,0 @@
-package simpledb.systemtest;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-
-import simpledb.*;
-
-import org.junit.Test;
-
-public class AggregateTest extends SimpleDbTestBase {
- public void validateAggregate(DbFile table, Aggregator.Op operation, int aggregateColumn, int groupColumn, ArrayList<ArrayList<Integer>> expectedResult)
- throws DbException, TransactionAbortedException, IOException {
- TransactionId tid = new TransactionId();
- SeqScan ss = new SeqScan(tid, table.getId(), "");
- Aggregate ag = new Aggregate(ss, aggregateColumn, groupColumn, operation);
-
- SystemTestUtil.matchTuples(ag, expectedResult);
- Database.getBufferPool().transactionComplete(tid);
- }
-
- private int computeAggregate(ArrayList<Integer> values, Aggregator.Op operation) {
- if (operation == Aggregator.Op.COUNT) return values.size();
-
- int value = 0;
- if (operation == Aggregator.Op.MIN) value = Integer.MAX_VALUE;
- else if (operation == Aggregator.Op.MAX) value = Integer.MIN_VALUE;
-
- for (int v : values) {
- switch (operation) {
- case MAX:
- if (v > value) value = v;
- break;
- case MIN:
- if (v < value) value = v;
- break;
- case AVG:
- case SUM:
- value += v;
- break;
- default:
- throw new IllegalArgumentException("Unsupported operation " + operation);
- }
- }
-
- if (operation == Aggregator.Op.AVG) value /= values.size();
- return value;
- }
-
- private ArrayList<ArrayList<Integer>> aggregate(ArrayList<ArrayList<Integer>> tuples, Aggregator.Op operation, int aggregateColumn, int groupColumn) {
- // Group the values
- HashMap<Integer, ArrayList<Integer>> values = new HashMap<Integer, ArrayList<Integer>>();
- for (ArrayList<Integer> t : tuples) {
- Integer key = null;
- if (groupColumn != Aggregator.NO_GROUPING) key = t.get(groupColumn);
- Integer value = t.get(aggregateColumn);
-
- if (!values.containsKey(key)) values.put(key, new ArrayList<Integer>());
- values.get(key).add(value);
- }
-
- ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
- for (Map.Entry<Integer, ArrayList<Integer>> e : values.entrySet()) {
- ArrayList<Integer> result = new ArrayList<Integer>();
- if (groupColumn != Aggregator.NO_GROUPING) result.add(e.getKey());
- result.add(computeAggregate(e.getValue(), operation));
- results.add(result);
- }
- return results;
- }
-
- private final static int ROWS = 1024;
- private final static int MAX_VALUE = 64;
- private final static int COLUMNS = 3;
- private void doAggregate(Aggregator.Op operation, int groupColumn)
- throws IOException, DbException, TransactionAbortedException {
- // Create the table
- ArrayList<ArrayList<Integer>> createdTuples = new ArrayList<ArrayList<Integer>>();
- HeapFile table = SystemTestUtil.createRandomHeapFile(
- COLUMNS, ROWS, MAX_VALUE, null, createdTuples);
-
- // Compute the expected answer
- ArrayList<ArrayList<Integer>> expected =
- aggregate(createdTuples, operation, 1, groupColumn);
-
- // validate that we get the answer
- validateAggregate(table, operation, 1, groupColumn, expected);
- }
-
- @Test public void testSum() throws IOException, DbException, TransactionAbortedException {
- doAggregate(Aggregator.Op.SUM, 0);
- }
-
- @Test public void testMin() throws IOException, DbException, TransactionAbortedException {
- doAggregate(Aggregator.Op.MIN, 0);
- }
-
- @Test public void testMax() throws IOException, DbException, TransactionAbortedException {
- doAggregate(Aggregator.Op.MAX, 0);
- }
-
- @Test public void testCount() throws IOException, DbException, TransactionAbortedException {
- doAggregate(Aggregator.Op.COUNT, 0);
- }
-
- @Test public void testAverage() throws IOException, DbException, TransactionAbortedException {
- doAggregate(Aggregator.Op.AVG, 0);
- }
-
- @Test public void testAverageNoGroup()
- throws IOException, DbException, TransactionAbortedException {
- doAggregate(Aggregator.Op.AVG, Aggregator.NO_GROUPING);
- }
-
- /** Make test compatible with older version of ant. */
- public static junit.framework.Test suite() {
- return new junit.framework.JUnit4TestAdapter(AggregateTest.class);
- }
-}
diff --git a/hw/hw3/starter-code/test/simpledb/systemtest/FilterBase.java b/hw/hw3/starter-code/test/simpledb/systemtest/FilterBase.java
deleted file mode 100644
index cd18945f8ca19801a2e5aca9b162a2d90b574095..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/systemtest/FilterBase.java
+++ /dev/null
@@ -1,85 +0,0 @@
-package simpledb.systemtest;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-
-import static org.junit.Assert.*;
-import org.junit.Test;
-
-import simpledb.*;
-
-public abstract class FilterBase extends SimpleDbTestBase {
- private static final int COLUMNS = 3;
- private static final int ROWS = 1097;
-
- /** Should apply the predicate to table. This will be executed in transaction tid. */
- protected abstract int applyPredicate(HeapFile table, TransactionId tid, Predicate predicate)
- throws DbException, TransactionAbortedException, IOException;
-
- /** Optional hook for validating database state after applyPredicate. */
- protected void validateAfter(HeapFile table)
- throws DbException, TransactionAbortedException, IOException {}
-
- protected ArrayList<ArrayList<Integer>> createdTuples;
-
- private int runTransactionForPredicate(HeapFile table, Predicate predicate)
- throws IOException, DbException, TransactionAbortedException {
- TransactionId tid = new TransactionId();
- int result = applyPredicate(table, tid, predicate);
- Database.getBufferPool().transactionComplete(tid);
- return result;
- }
-
- private void validatePredicate(int column, int columnValue, int trueValue, int falseValue,
- Predicate.Op operation) throws IOException, DbException, TransactionAbortedException {
- // Test the true value
- HeapFile f = createTable(column, columnValue);
- Predicate predicate = new Predicate(column, operation, new IntField(trueValue));
- assertEquals(ROWS, runTransactionForPredicate(f, predicate));
- f = Utility.openHeapFile(COLUMNS, f.getFile());
- validateAfter(f);
-
- // Test the false value
- f = createTable(column, columnValue);
- predicate = new Predicate(column, operation, new IntField(falseValue));
- assertEquals(0, runTransactionForPredicate(f, predicate));
- f = Utility.openHeapFile(COLUMNS, f.getFile());
- validateAfter(f);
- }
-
- private HeapFile createTable(int column, int columnValue)
- throws IOException, DbException, TransactionAbortedException {
- Map<Integer, Integer> columnSpecification = new HashMap<Integer, Integer>();
- columnSpecification.put(column, columnValue);
- createdTuples = new ArrayList<ArrayList<Integer>>();
- return SystemTestUtil.createRandomHeapFile(
- COLUMNS, ROWS, columnSpecification, createdTuples);
- }
-
- @Test public void testEquals() throws
- DbException, TransactionAbortedException, IOException {
- validatePredicate(0, 1, 1, 2, Predicate.Op.EQUALS);
- }
-
- @Test public void testLessThan() throws
- DbException, TransactionAbortedException, IOException {
- validatePredicate(1, 1, 2, 1, Predicate.Op.LESS_THAN);
- }
-
- @Test public void testLessThanOrEq() throws
- DbException, TransactionAbortedException, IOException {
- validatePredicate(2, 42, 42, 41, Predicate.Op.LESS_THAN_OR_EQ);
- }
-
- @Test public void testGreaterThan() throws
- DbException, TransactionAbortedException, IOException {
- validatePredicate(2, 42, 41, 42, Predicate.Op.GREATER_THAN);
- }
-
- @Test public void testGreaterThanOrEq() throws
- DbException, TransactionAbortedException, IOException {
- validatePredicate(2, 42, 42, 43, Predicate.Op.GREATER_THAN_OR_EQ);
- }
-}
diff --git a/hw/hw3/starter-code/test/simpledb/systemtest/FilterTest.java b/hw/hw3/starter-code/test/simpledb/systemtest/FilterTest.java
deleted file mode 100644
index eeba3df487baa4b063dc4130527833e0b4b21a34..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/systemtest/FilterTest.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package simpledb.systemtest;
-
-import java.io.IOException;
-import static org.junit.Assert.*;
-import simpledb.*;
-
-public class FilterTest extends FilterBase {
- @Override
- protected int applyPredicate(HeapFile table, TransactionId tid, Predicate predicate)
- throws DbException, TransactionAbortedException, IOException {
- SeqScan ss = new SeqScan(tid, table.getId(), "");
- Filter filter = new Filter(predicate, ss);
- filter.open();
-
- int resultCount = 0;
- while (filter.hasNext()) {
- assertNotNull(filter.next());
- resultCount += 1;
- }
-
- filter.close();
- return resultCount;
- }
-
- /** Make test compatible with older version of ant. */
- public static junit.framework.Test suite() {
- return new junit.framework.JUnit4TestAdapter(FilterTest.class);
- }
-}
diff --git a/hw/hw3/starter-code/test/simpledb/systemtest/JoinTest.java b/hw/hw3/starter-code/test/simpledb/systemtest/JoinTest.java
deleted file mode 100644
index 337d4232eaa73db610e3d21c67998919fc1f18b9..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/systemtest/JoinTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-package simpledb.systemtest;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-
-import org.junit.Test;
-
-import simpledb.*;
-
-public class JoinTest extends SimpleDbTestBase {
- private static final int COLUMNS = 2;
- public void validateJoin(int table1ColumnValue, int table1Rows, int table2ColumnValue,
- int table2Rows)
- throws IOException, DbException, TransactionAbortedException {
- // Create the two tables
- HashMap<Integer, Integer> columnSpecification = new HashMap<Integer, Integer>();
- columnSpecification.put(0, table1ColumnValue);
- ArrayList<ArrayList<Integer>> t1Tuples = new ArrayList<ArrayList<Integer>>();
- HeapFile table1 = SystemTestUtil.createRandomHeapFile(
- COLUMNS, table1Rows, columnSpecification, t1Tuples);
- assert t1Tuples.size() == table1Rows;
-
- columnSpecification.put(0, table2ColumnValue);
- ArrayList<ArrayList<Integer>> t2Tuples = new ArrayList<ArrayList<Integer>>();
- HeapFile table2 = SystemTestUtil.createRandomHeapFile(
- COLUMNS, table2Rows, columnSpecification, t2Tuples);
- assert t2Tuples.size() == table2Rows;
-
- // Generate the expected results
- ArrayList<ArrayList<Integer>> expectedResults = new ArrayList<ArrayList<Integer>>();
- for (ArrayList<Integer> t1 : t1Tuples) {
- for (ArrayList<Integer> t2 : t2Tuples) {
- // If the columns match, join the tuples
- if (t1.get(0).equals(t2.get(0))) {
- ArrayList<Integer> out = new ArrayList<Integer>(t1);
- out.addAll(t2);
- expectedResults.add(out);
- }
- }
- }
-
- // Begin the join
- TransactionId tid = new TransactionId();
- SeqScan ss1 = new SeqScan(tid, table1.getId(), "");
- SeqScan ss2 = new SeqScan(tid, table2.getId(), "");
- JoinPredicate p = new JoinPredicate(0, Predicate.Op.EQUALS, 0);
- Join joinOp = new Join(p, ss1, ss2);
-
- // test the join results
- SystemTestUtil.matchTuples(joinOp, expectedResults);
-
- joinOp.close();
- Database.getBufferPool().transactionComplete(tid);
- }
-
- @Test public void testSingleMatch()
- throws IOException, DbException, TransactionAbortedException {
- validateJoin(1, 1, 1, 1);
- }
-
- @Test public void testNoMatch()
- throws IOException, DbException, TransactionAbortedException {
- validateJoin(1, 2, 2, 10);
- }
-
- @Test public void testMultipleMatch()
- throws IOException, DbException, TransactionAbortedException {
- validateJoin(1, 3, 1, 3);
- }
-
- /** Make test compatible with older version of ant. */
- public static junit.framework.Test suite() {
- return new junit.framework.JUnit4TestAdapter(JoinTest.class);
- }
-}
diff --git a/hw/hw3/starter-code/test/simpledb/systemtest/ScanTest.java b/hw/hw3/starter-code/test/simpledb/systemtest/ScanTest.java
deleted file mode 100644
index 5352516a4105f0790710ea9b0365a6043f5f547b..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/systemtest/ScanTest.java
+++ /dev/null
@@ -1,111 +0,0 @@
-package simpledb.systemtest;
-
-import simpledb.systemtest.SystemTestUtil;
-
-import static org.junit.Assert.*;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.NoSuchElementException;
-import java.util.Random;
-
-import org.junit.Test;
-
-import simpledb.*;
-
-/**
- * Dumps the contents of a table.
- * args[1] is the number of columns. E.g., if it's 5, then ScanTest will end
- * up dumping the contents of f4.0.txt.
- */
-public class ScanTest extends SimpleDbTestBase {
- private final static Random r = new Random();
-
- /** Tests the scan operator for a table with the specified dimensions. */
- private void validateScan(int[] columnSizes, int[] rowSizes)
- throws IOException, DbException, TransactionAbortedException {
- for (int columns : columnSizes) {
- for (int rows : rowSizes) {
- ArrayList<ArrayList<Integer>> tuples = new ArrayList<ArrayList<Integer>>();
- HeapFile f = SystemTestUtil.createRandomHeapFile(columns, rows, null, tuples);
- SystemTestUtil.matchTuples(f, tuples);
- Database.resetBufferPool(BufferPool.DEFAULT_PAGES);
- }
- }
- }
-
- /** Scan 1-4 columns. */
- @Test public void testSmall() throws IOException, DbException, TransactionAbortedException {
- int[] columnSizes = new int[]{1, 2, 3, 4};
- int[] rowSizes =
- new int[]{0, 1, 2, 511, 512, 513, 1023, 1024, 1025, 4096 + r.nextInt(4096)};
- validateScan(columnSizes, rowSizes);
- }
-
- /** Test that rewinding a SeqScan iterator works. */
- @Test public void testRewind() throws IOException, DbException, TransactionAbortedException {
- ArrayList<ArrayList<Integer>> tuples = new ArrayList<ArrayList<Integer>>();
- HeapFile f = SystemTestUtil.createRandomHeapFile(2, 1000, null, tuples);
-
- TransactionId tid = new TransactionId();
- SeqScan scan = new SeqScan(tid, f.getId(), "table");
- scan.open();
- for (int i = 0; i < 100; ++i) {
- assertTrue(scan.hasNext());
- Tuple t = scan.next();
- assertEquals(tuples.get(i), SystemTestUtil.tupleToList(t));
- }
-
- scan.rewind();
- for (int i = 0; i < 100; ++i) {
- assertTrue(scan.hasNext());
- Tuple t = scan.next();
- assertEquals(tuples.get(i), SystemTestUtil.tupleToList(t));
- }
- scan.close();
- Database.getBufferPool().transactionComplete(tid);
- }
-
- /** Verifies that the buffer pool is actually caching data.
- * @throws TransactionAbortedException
- * @throws DbException */
- @Test public void testCache() throws IOException, DbException, TransactionAbortedException {
- /** Counts the number of readPage operations. */
- class InstrumentedHeapFile extends HeapFile {
- public InstrumentedHeapFile(File f, TupleDesc td) {
- super(f, td);
- }
-
- @Override
- public Page readPage(PageId pid) throws NoSuchElementException {
- readCount += 1;
- return super.readPage(pid);
- }
-
- public int readCount = 0;
- }
-
- // Create the table
- final int PAGES = 30;
- ArrayList<ArrayList<Integer>> tuples = new ArrayList<ArrayList<Integer>>();
- File f = SystemTestUtil.createRandomHeapFileUnopened(1, 992*PAGES, 1000, null, tuples);
- TupleDesc td = Utility.getTupleDesc(1);
- InstrumentedHeapFile table = new InstrumentedHeapFile(f, td);
- Database.getCatalog().addTable(table, SystemTestUtil.getUUID());
-
- // Scan the table once
- SystemTestUtil.matchTuples(table, tuples);
- assertEquals(PAGES, table.readCount);
- table.readCount = 0;
-
- // Scan the table again: all pages should be cached
- SystemTestUtil.matchTuples(table, tuples);
- assertEquals(0, table.readCount);
- }
-
- /** Make test compatible with older version of ant. */
- public static junit.framework.Test suite() {
- return new junit.framework.JUnit4TestAdapter(ScanTest.class);
- }
-}
diff --git a/hw/hw3/starter-code/test/simpledb/systemtest/SimpleDbTestBase.java b/hw/hw3/starter-code/test/simpledb/systemtest/SimpleDbTestBase.java
deleted file mode 100644
index e2b0e68f2a0eb47137208c79c591c54caeea10c5..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/systemtest/SimpleDbTestBase.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package simpledb.systemtest;
-
-import org.junit.Before;
-
-import simpledb.Database;
-
-/**
- * Base class for all SimpleDb test classes.
- * @author nizam
- *
- */
-public class SimpleDbTestBase {
- /**
- * Reset the database before each test is run.
- */
- @Before public void setUp() throws Exception {
- Database.reset();
- }
-
-}
diff --git a/hw/hw3/starter-code/test/simpledb/systemtest/SystemTestUtil.java b/hw/hw3/starter-code/test/simpledb/systemtest/SystemTestUtil.java
deleted file mode 100644
index 70b67ef78e59a07f6f11923bfd5b92801f9bf53e..0000000000000000000000000000000000000000
--- a/hw/hw3/starter-code/test/simpledb/systemtest/SystemTestUtil.java
+++ /dev/null
@@ -1,230 +0,0 @@
-package simpledb.systemtest;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Random;
-import java.util.UUID;
-
-import org.junit.Assert;
-
-import simpledb.*;
-
-public class SystemTestUtil {
- public static final TupleDesc SINGLE_INT_DESCRIPTOR =
- new TupleDesc(new Type[]{Type.INT_TYPE});
-
- private static final int MAX_RAND_VALUE = 1 << 16;
-
- /** @param columnSpecification Mapping between column index and value. */
- public static HeapFile createRandomHeapFile(
- int columns, int rows, Map<Integer, Integer> columnSpecification,
- ArrayList<ArrayList<Integer>> tuples)
- throws IOException, DbException, TransactionAbortedException {
- return createRandomHeapFile(columns, rows, MAX_RAND_VALUE, columnSpecification, tuples);
- }
-
- /** @param columnSpecification Mapping between column index and value. */
- public static HeapFile createRandomHeapFile(
- int columns, int rows, int maxValue, Map<Integer, Integer> columnSpecification,
- ArrayList<ArrayList<Integer>> tuples)
- throws IOException, DbException, TransactionAbortedException {
- File temp = createRandomHeapFileUnopened(columns, rows, maxValue,
- columnSpecification, tuples);
- return Utility.openHeapFile(columns, temp);
- }
-
- public static HeapFile createRandomHeapFile(
- int columns, int rows, Map<Integer, Integer> columnSpecification,
- ArrayList<ArrayList<Integer>> tuples, String colPrefix)
- throws IOException, DbException, TransactionAbortedException {
- return createRandomHeapFile(columns, rows, MAX_RAND_VALUE, columnSpecification, tuples, colPrefix);
- }
-
- public static HeapFile createRandomHeapFile(
- int columns, int rows, int maxValue, Map<Integer, Integer> columnSpecification,
- ArrayList<ArrayList<Integer>> tuples, String colPrefix)
- throws IOException, DbException, TransactionAbortedException {
- File temp = createRandomHeapFileUnopened(columns, rows, maxValue,
- columnSpecification, tuples);
- return Utility.openHeapFile(columns, colPrefix, temp);
- }
-
- public static File createRandomHeapFileUnopened(int columns, int rows,
- int maxValue, Map<Integer, Integer> columnSpecification,
- ArrayList<ArrayList<Integer>> tuples) throws IOException {
- if (tuples != null) {
- tuples.clear();
- } else {
- tuples = new ArrayList<ArrayList<Integer>>(rows);
- }
-
- Random r = new Random();
-
- // Fill the tuples list with generated values
- for (int i = 0; i < rows; ++i) {
- ArrayList<Integer> tuple = new ArrayList<Integer>(columns);
- for (int j = 0; j < columns; ++j) {
- // Generate random values, or use the column specification
- Integer columnValue = null;
- if (columnSpecification != null) columnValue = columnSpecification.get(j);
- if (columnValue == null) {
- columnValue = r.nextInt(maxValue);
- }
- tuple.add(columnValue);
- }
- tuples.add(tuple);
- }
-
- // Convert the tuples list to a heap file and open it
- File temp = File.createTempFile("table", ".dat");
- temp.deleteOnExit();
- HeapFileEncoder.convert(tuples, temp, BufferPool.getPageSize(), columns);
- return temp;
- }
-
- public static ArrayList<Integer> tupleToList(Tuple tuple) {
- ArrayList<Integer> list = new ArrayList<Integer>();
- for (int i = 0; i < tuple.getTupleDesc().numFields(); ++i) {
- int value = ((IntField)tuple.getField(i)).getValue();
- list.add(value);
- }
- return list;
- }
-
- public static void matchTuples(DbFile f, List<ArrayList<Integer>> tuples)
- throws DbException, TransactionAbortedException, IOException {
- TransactionId tid = new TransactionId();
- matchTuples(f, tid, tuples);
- Database.getBufferPool().transactionComplete(tid);
- }
-
- public static void matchTuples(DbFile f, TransactionId tid, List<ArrayList<Integer>> tuples)
- throws DbException, TransactionAbortedException, IOException {
- SeqScan scan = new SeqScan(tid, f.getId(), "");
- matchTuples(scan, tuples);
- }
-
- public static void matchTuples(DbIterator iterator, List<ArrayList<Integer>> tuples)
- throws DbException, TransactionAbortedException, IOException {
- ArrayList<ArrayList<Integer>> copy = new ArrayList<ArrayList<Integer>>(tuples);
-
- if (Debug.isEnabled()) {
- Debug.log("Expected tuples:");
- for (ArrayList<Integer> t : copy) {
- Debug.log("\t" + Utility.listToString(t));
- }
- }
-
- iterator.open();
- while (iterator.hasNext()) {
- Tuple t = iterator.next();
- ArrayList<Integer> list = tupleToList(t);
- boolean isExpected = copy.remove(list);
- Debug.log("scanned tuple: %s (%s)", t, isExpected ? "expected" : "not expected");
- if (!isExpected) {
- Assert.fail("expected tuples does not contain: " + t);
- }
- }
- iterator.close();
-
- if (!copy.isEmpty()) {
- String msg = "expected to find the following tuples:\n";
- final int MAX_TUPLES_OUTPUT = 10;
- int count = 0;
- for (ArrayList<Integer> t : copy) {
- if (count == MAX_TUPLES_OUTPUT) {
- msg += "[" + (copy.size() - MAX_TUPLES_OUTPUT) + " more tuples]";
- break;
- }
- msg += "\t" + Utility.listToString(t) + "\n";
- count += 1;
- }
- Assert.fail(msg);
- }
- }
-
- /**
- * Returns number of bytes of RAM used by JVM after calling System.gc many times.
- * @return amount of RAM (in bytes) used by JVM
- */
- public static long getMemoryFootprint() {
- // Call System.gc in a loop until it stops freeing memory. This is
- // still no guarantee that all the memory is freed, since System.gc is
- // just a "hint".
- Runtime runtime = Runtime.getRuntime();
- long memAfter = runtime.totalMemory() - runtime.freeMemory();
- long memBefore = memAfter + 1;
- while (memBefore != memAfter) {
- memBefore = memAfter;
- System.gc();
- memAfter = runtime.totalMemory() - runtime.freeMemory();
- }
-
- return memAfter;
- }
-
- /**
- * Generates a unique string each time it is called.
- * @return a new unique UUID as a string, using java.util.UUID
- */
- public static String getUUID() {
- return UUID.randomUUID().toString();
- }
-
- private static double[] getDiff(double[] sequence) {
- double ret[] = new double[sequence.length - 1];
- for (int i = 0; i < sequence.length - 1; ++i)
- ret[i] = sequence[i + 1] - sequence[i];
- return ret;
- }
- /**
- * Checks if the sequence represents a quadratic sequence (approximately)
- * ret[0] is true if the sequence is quadratic
- * ret[1] is the common difference of the sequence if ret[0] is true.
- * @param sequence
- * @return ret[0] = true if sequence is qudratic(or sub-quadratic or linear), ret[1] = the coefficient of n^2
- */
- public static Object[] checkQuadratic(double[] sequence) {
- Object ret[] = checkLinear(getDiff(sequence));
- ret[1] = (Double)ret[1]/2.0;
- return ret;
- }
-
- /**
- * Checks if the sequence represents an arithmetic sequence (approximately)
- * ret[0] is true if the sequence is linear
- * ret[1] is the common difference of the sequence if ret[0] is true.
- * @param sequence
- * @return ret[0] = true if sequence is linear, ret[1] = the common difference
- */
- public static Object[] checkLinear(double[] sequence) {
- return checkConstant(getDiff(sequence));
- }
-
- /**
- * Checks if the sequence represents approximately a fixed sequence (c,c,c,c,..)
- * ret[0] is true if the sequence is linear
- * ret[1] is the constant of the sequence if ret[0] is true.
- * @param sequence
- * @return ret[0] = true if sequence is constant, ret[1] = the constant
- */
- public static Object[] checkConstant(double[] sequence) {
- Object[] ret = new Object[2];
- //compute average
- double sum = .0;
- for(int i = 0; i < sequence.length; ++i)
- sum += sequence[i];
- double av = sum/(sequence.length + .0);
- //compute standard deviation
- double sqsum = 0;
- for(int i = 0; i < sequence.length; ++i)
- sqsum += (sequence[i] - av)*(sequence[i] - av);
- double std = Math.sqrt(sqsum/(sequence.length + .0));
- ret[0] = std < 1.0 ? Boolean.TRUE : Boolean.FALSE;
- ret[1] = av;
- return ret;
- }
-}