Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
かわいいデータベース
package kis.basicdb;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
import java.util.Set;
import java.util.TreeMap;
/**
* Relational Database
*
*/
public class App
{
public static void main( String[] args )
{
//商品テーブル
Table shohin = Table.create("shohin",
new String[]{"shohin_id", "shohin_name", "kubun_id", "price"});
shohin.insert(1, "りんご", 1, 300)
.insert(2, "みかん", 1, 130)
.insert(3, "キャベツ", 2, 200)
.insert(4, "さんま", 3, 220)
.insert(5, "わかめ", null, 250)//区分がnull
.insert(6, "しいたけ", 4, 180)//該当区分なし
.insert(7, "ドリアン", 1, null);
//区分テーブル
Table kubun = Table.create("kubun",
new String[]{"kubun_id", "kubun_name"});
kubun.insert(1, "くだもの")
.insert(2, "野菜")
.insert(3, "");
//インデックス追加
shohin.addIndex("shohin_id", IndexType.HASH);
shohin.addIndex("price", IndexType.TREE);
kubun.addIndex("kubun_id", IndexType.HASH);
System.out.println(shohin);//テーブル内容
System.out.println(Query.from("shohin"));//クエリー経由でテーブル内容
System.out.println(Query.from("shohin").select("shohin_name", "price"));//射影
System.out.println(Query.from("shohin").lessThan("price", 250));//フィルター
System.out.println(Query.from("shohin").leftJoin("kubun", "kubun_id"));//結合
System.out.println(Query.from("shohin").leftJoin("kubun", "kubun_id")//全部入り
.lessThan("price", 200).select("shohin_name", "kubun_name", "price"));
System.out.println(Query //サブクエリー
.from(Query.from("shohin").lessThan("price", 250))
.leftJoin(Query.from("kubun").lessThan("kubun_id", 3), "kubun_id"));
System.out.println(Query //一致比較
.from("shohin")
.leftJoin("kubun", "kubun_id")
.equalsTo("shohin_id", 2)
.select("shohin_id", "shohin_name", "kubun_name", "price"));
System.out.println(Query //安い順に並べ替え
.from("shohin")
.orderBy("price"));
System.out.println(Query //高い順に並べ替え
.from("shohin")
.orderBy("price", false));
System.out.println(Query //集計
.from(Query
.from("shohin")
.groupBy("kubun_id", new Count("shohin_name"), new Average("price")))
.leftJoin("kubun", "kubun_id")
.select("kubun_id", "kubun_name", "count", "average"));
System.out.println("between");
System.out.println(Query
.from("shohin").between("price", 200, 250));
System.out.println(Query
.from("shohin").between("price", 100, 150)
.union(Query
.from("shohin").between("price", 250, 300), true));
System.out.println(Query
.from("shohin").between("price", 150, 200)
.union(Query
.from("shohin").between("price", 200, 250), true));
System.out.println(Query
.from("shohin").between("price", 150, 200)
.union(Query
.from("shohin").between("price", 200, 250), false));
//nullだったpriceに値を設定してみる
Query.from("shohin").equalsTo("shohin_id", 7).update(new SubstOperation("price", 150));
System.out.println(shohin);
//ためしに抽出
System.out.println(Query.from("shohin").lessThan("price", 200));
//値を変更
Query.from("shohin").equalsTo("shohin_id", 7).update(new SubstOperation("price", 80));
System.out.println(Query.from("shohin").lessThan("price", 200));
//一括変更
Query.from("shohin").lessThan("price", 200).update(new AddOperation("price", 10));
System.out.println(Query.from("shohin").lessThan("price", 200));
//値をnullに
Query.from("shohin").equalsTo("shohin_id", 2).update(new SubstOperation("price", null));
System.out.println(Query.from("shohin").lessThan("price", 200));
//削除
Query.from("shohin").equalsTo("shohin_id", 7).delete();
System.out.println(Query.from("shohin").lessThan("price", 200));
}
/** テーブル一覧 */
private static Map<String, Table> tables = new HashMap<>();
/** クエリーの起点 */
public static class Query{
/**
* クエリーのベースになるテーブルを選択
* @param tableName テーブル名
* @return
*/
public static QueryObj from(String tableName){
return from(tables.get(tableName));
}
/**
* クエリーのベースになるリレーションを選択
* @param tableName テーブル名
* @return
*/
public static QueryObj from(QueryObj relation){
return relation;
}
}
/** クエリーとして利用できるメソッド(補完時に不要なメソッドを出さないため) */
public interface QueryObj{
/**
* left join
* @param tableName 右側テーブル名
* @param matchingField 値を結合する基準になる属性名
* @return
*/
QueryObj leftJoin(String tableName, String matchingField);
QueryObj leftJoin(QueryObj relation, String matchingField);
/**
* 指定した値よりも小さいタプルを抽出
* @param columnName 比較するフィールド名
* @param value 比較する値
* @return
*/
QueryObj lessThan(String columnName, Integer value);
/**
* 指定した値の間のタプルを抽出
* @param columnName 比較するフィールド名
* @param lower 抽出範囲の下側
* @param upper 抽出範囲の上側
* @return
*/
QueryObj between(String columnName, Integer lower, Integer upper);
/**
* 指定した値に一致するタプルを抽出
* @param columnName 比較するフィールド名
* @param value 比較する値
* @return
*/
QueryObj equalsTo(String columnName, Object value);
/**
* 射影
* @param columnNames 抽出するフィールド名
* @return
*/
QueryObj select(String... columnNames);
/**
* 昇順に並べ替え
* @param columnName 並べ替えるフィールド名
* @return
*/
QueryObj orderBy(String columnName);
/**
* 並べ替え
* @param columnName 並べ替えるフィールド名
* @param asc 昇順のばあいtrue
* @return
*/
QueryObj orderBy(String columnName, boolean asc);
/**
* グループ化
* @param columnName グループ化するフィールド名
* @param aggregations 集計関数
* @return
*/
QueryObj groupBy(String columnName, Aggregation... aggregations);
/**
* 変更
* @param op 変更するフィールド
*/
void update(UpdateOperation... op);
/**
* 削除
*/
void delete();
/**
* 連結
* 行の数や名前、順番が一致しない場合は連結しない
* @param relation 連結対象
* @param distinct テーブル同士の連結の場合、重複を省く
*/
QueryObj union(QueryObj relation, boolean distinct);
}
/** 集計関数の基底 */
public static abstract class Aggregation{
String columnName;
public Aggregation(String columnName) {
this.columnName = columnName;
}
/** 関数名 */
public abstract String getName();
/** データ追加 */
public abstract void addData(Object value);
/** 結果取得 */
public abstract Object getResult();
/** リセット */
public abstract void reset();
}
/** 集計用カウント関数 */
public static class Count extends Aggregation{
int counter = 0;
@Override
public String getName() {
return "count";
}
public Count(String columnName) {
super(columnName);
}
@Override
public void addData(Object value) {
++counter;
}
@Override
public Object getResult() {
return counter;
}
@Override
public void reset() {
counter = 0;
}
}
/** 集計用平均関数 */
public static class Average extends Aggregation{
int counter = 0;
int total = 0;
public Average(String columnName) {
super(columnName);
}
@Override
public String getName() {
return "average";
}
@Override
public void addData(Object value) {
++counter;
total += (Integer)value;
}
@Override
public Object getResult() {
return (double)total / counter;
}
@Override
public void reset() {
counter = 0;
total = 0;
}
}
/** リレーション */
public static abstract class AbstractRelation implements QueryObj{
public abstract List<Column> getColumns();
public abstract List<Taple> getTaples();
/**
* 射影
*/
@Override
public QueryObj select(String... columnNames){
List<Integer> indexes = new ArrayList<>();
List<Column> newColumns = new ArrayList<>();
for(String n : columnNames){
newColumns.add(new Column(n));
//属性を探す
int idx = findColumn(n);
indexes.add(idx);
}
//データの投影
List<Taple> newTaples = new ArrayList<>();
for(Taple tp : getTaples()){
List<Object> values = new ArrayList<>();
for(int idx : indexes){
if(idx < tp.values.size()){
values.add(tp.values.get(idx));
}else{
values.add(null);
}
}
newTaples.add(new Taple(values));
}
return new Relation(newColumns, newTaples);
}
/**
* left join
*/
@Override
public QueryObj leftJoin(String tableName, String matchingField){
//テーブル取得
Table tbl = tables.get(tableName);
return leftJoin(tbl, matchingField);
}
@Override
public QueryObj leftJoin(QueryObj relation, String matchingField){
Relation tbl = (Relation) relation;
//属性の作成
List<Column> newColumns = new ArrayList<>(getColumns());
newColumns.addAll(tbl.getColumns());
//値の作成
List<Taple> newTaples = new ArrayList<>();
int leftColumnIdx = findColumn(matchingField);
int rightColumnIdx = tbl.findColumn(matchingField);
if(leftColumnIdx >= getColumns().size() || rightColumnIdx >= tbl.getColumns().size()){
//該当フィールドがない場合は値の結合をしない
return new Relation(newColumns, Collections.EMPTY_LIST);
}
//結合処理
for(Taple tp : getTaples()){
//元のテーブルのデータ
Taple ntpl = new Taple(new ArrayList<>(tp.values));
//足りないフィールドを埋める
while(ntpl.values.size() < getColumns().size()){
ntpl.values.add(null);
}
//結合対象のフィールドを探す
Object leftValue = ntpl.values.get(leftColumnIdx);
//結合するタプルを抽出
Relation leftRel = (Relation)relation.equalsTo(matchingField, leftValue);
//一致するタプルがあれば結合
if(!leftRel.taples.isEmpty()){
for(Object v : leftRel.getTaples().get(0).values){//今回は、タプルの対応は一対一まで
ntpl.values.add(v);
}
}
//足りないフィールドを埋める
while(ntpl.values.size() < newColumns.size()){
ntpl.values.add(null);
}
newTaples.add(ntpl);
}
return new Relation(newColumns, newTaples);
}
/**
* 指定した値よりも小さいタプルを抽出
*/
@Override
public QueryObj lessThan(String columnName, Integer value){
if(value == null){
return new Relation(getColumns(), Collections.EMPTY_LIST);
}
int idx = findColumn(columnName);
if(idx >= getColumns().size()){
return new Relation(getColumns(), Collections.EMPTY_LIST);
}
List<Taple> newTaples = new ArrayList<>();
for(Taple tp : getTaples()){
try{
if((Integer)tp.values.get(idx) < value){
newTaples.add(tp);
}
}catch(NullPointerException | ArrayIndexOutOfBoundsException ex){}
}
return new Relation(getColumns(), newTaples);
}
/**
* 指定した値に一致するタプルを抽出
*/
@Override
public QueryObj equalsTo(String columnName, Object value) {
if(value == null){
return new Relation(getColumns(), Collections.EMPTY_LIST);
}
int idx = findColumn(columnName);
if(idx >= getColumns().size()){
return new Relation(getColumns(), Collections.EMPTY_LIST);
}
List<Taple> newTaples = new ArrayList<>();
for(Taple tp : getTaples()){
if(value.equals(tp.values.get(idx))){
newTaples.add(tp);
}
}
return new Relation(getColumns(), newTaples);
}
@Override
public QueryObj between(String columnName, Integer lower, Integer upper) {
if(lower == null || upper == null){
return new Relation(getColumns(), Collections.EMPTY_LIST);
}
int idx = findColumn(columnName);
if(idx >= getColumns().size()){
return new Relation(getColumns(), Collections.EMPTY_LIST);
}
List<Taple> newTaples = new ArrayList<>();
for(Taple tp : getTaples()){
try{
int v = (Integer)tp.values.get(idx);
if(lower <= v && v <= upper){
newTaples.add(tp);
}
}catch(NullPointerException | ArrayIndexOutOfBoundsException ex){}
}
return new Relation(getColumns(), newTaples);
}
@Override
public QueryObj orderBy(String columnName) {
return orderBy(columnName, true);
}
@Override
public QueryObj orderBy(String columnName, final boolean asc) {
final int idx = findColumn(columnName);
if(idx >= getColumns().size()){
return this;
}
List<Taple> newTaple = new ArrayList<>(getTaples());
Collections.sort(newTaple, new Comparator<Taple>(){
@Override
public int compare(Taple o1, Taple o2) {
Object v1 = o1.values.size() > idx ? o1.values.get(idx) : null;
Object v2 = o2.values.size() > idx ? o2.values.get(idx) : null;
if(v1 == null){
if(v2 == null){
return 0;
}else{
return 1;
}
}
if(v2 == null){
return -1;
}
return ((Comparable)v1).compareTo(v2) * (asc ? 1 : -1);
}
});
return new Relation(getColumns(), newTaple);
}
@Override
public QueryObj groupBy(String columnName, Aggregation... aggregations) {
//列名を作成
List<Column> newColumns = new ArrayList<>();
newColumns.add(new Column(columnName));
List<Integer> colIndexes = new ArrayList<>();
for(Aggregation agg : aggregations){
newColumns.add(new Column(agg.getName()));
colIndexes.add(findColumn(agg.columnName));
}
//集計行を取得
int idx = findColumn(columnName);
if(idx >= getColumns().size()){
return new Relation(newColumns, Collections.EMPTY_LIST);
}
//あらかじめソート
Relation sorted = (Relation) orderBy(columnName);
Object current = null;
List<Taple> newTaples = new ArrayList<>();
for(Taple tp : sorted.getTaples()){
//集計フィールド取得
if(tp.values.size() <= idx) continue;
Object v = tp.values.get(idx);
if(v == null) continue;
if(!v.equals(current)){
if(current != null){
//集計行を追加
List<Object> values = new ArrayList<>();
values.add(current);
for(Aggregation agg : aggregations){
values.add(agg.getResult());
}
newTaples.add(new Taple(values));
}
current = v;
for(Aggregation agg : aggregations){
agg.reset();
}
}
//集計
for(int i = 0; i < aggregations.length; ++i){
int aidx = colIndexes.get(i);
if(tp.values.size() <= aidx) continue;
Object cv = tp.values.get(aidx);
if(cv == null) continue;
Aggregation ag = aggregations[i];
ag.addData(cv);
}
}
if(current != null){
//集計行を追加
List<Object> values = new ArrayList<>();
values.add(current);
for(Aggregation agg : aggregations){
values.add(agg.getResult());
}
newTaples.add(new Taple(values));
}
return new Relation(newColumns, newTaples);
}
/**
* データ更新
* @param op 更新
*/
@Override
public void update(UpdateOperation... op){
ArrayList<Taple> iterateTaples = new ArrayList<>(getTaples());//ループ中で要素を削除する可能性があるため
for(Taple tp : iterateTaples){
if(tp instanceof TableTaple){
((TableTaple)tp).parent.execUpdate(tp, op);
}
}
}
/**
* データ削除
*/
@Override
public void delete(){
ArrayList<Taple> iterateTaples = new ArrayList<>(getTaples());//ループ中で要素を削除する可能性があるため
for(Taple tp : iterateTaples){
if(tp instanceof TableTaple){
((TableTaple)tp).parent.execDelete(tp);
}
}
}
@Override
public QueryObj union(QueryObj relation, boolean distinct) {
AbstractRelation rel = (AbstractRelation) relation;
//カラムの比較
if(getColumns().size() != rel.getColumns().size()){
//カラム数が違う
return this;
}
for(int i = 0; i < getColumns().size(); ++i){
if(!getColumns().get(i).name.equals(rel.getColumns().get(i).name)){
//名前が違う
return this;
}
}
List<Taple> result = new ArrayList<>();
Set<Long> oids = new HashSet<>();
//元データの追加
for(Taple tp : getTaples()){
if(distinct && tp instanceof TableTaple){
//重複チェック
long oid = ((TableTaple)tp).oid;
if(oids.contains(oid)){
continue;
}
oids.add(oid);
}
result.add(tp);
}
//unionデータの追加
for(Taple tp : rel.getTaples()){
if(distinct && tp instanceof TableTaple){
//重複チェック
long oid = ((TableTaple)tp).oid;
if(oids.contains(oid)){
continue;
}
oids.add(oid);
}
result.add(tp);
}
return new Relation(getColumns(), result);
}
/**
* 属性を探す
* @param name 属性名
* @return 属性のインデックス。みつからなかったときは属性数(インデックスからあふれる)を返す
*/
public int findColumn(String name){
for(int i = 0; i < getColumns().size(); ++i){
if(getColumns().get(i).name.equals(name)){
return i;
}
}
return getColumns().size();
}
@Override
public String toString() {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
//フィールド名
for(Column cl : getColumns()){
pw.print("|");
if(cl.parent != null && !cl.parent.isEmpty()){
pw.print(cl.parent + ".");
}
pw.print(cl.name);
}
pw.println("|");
//データ
int c = 0;
for(Taple t : getTaples()){
for(Object v : t.values){
pw.print("|");
pw.print(v);
}
pw.println("|");
++c;
if(c > 10) break;
}
return sw.toString();
}
}
/** アップデート用演算 */
public static abstract class UpdateOperation{
String tapleName;
Object value;
public UpdateOperation(String tapleName, Object value) {
this.tapleName = tapleName;
this.value = value;
}
public abstract Object eval(Object oldValue);
}
/** 代入 */
public static class SubstOperation extends UpdateOperation{
public SubstOperation(String tapleName, Object value) {
super(tapleName, value);
}
@Override
public Object eval(Object oldValue) {
return value;
}
}
/** 足し算 */
public static class AddOperation extends UpdateOperation{
public AddOperation(String tapleName, int value) {
super(tapleName, value);
}
@Override
public Object eval(Object oldValue){
return (Integer)oldValue + (Integer)value;
}
}
public static class Relation extends AbstractRelation{
/** 属性 */
private List<Column> columns;
/** データ */
private List<Taple> taples;
public Relation(List<Column> columns, List<Taple> taples) {
this.columns = columns;
this.taples = taples;
}
@Override
public List<Column> getColumns() {
return columns;
}
@Override
public List<Taple> getTaples() {
return taples;
}
}
/** 現在のオブジェクトID */
static long currentOid = 0;
/** テーブル */
public static class Table extends Relation{
/** テーブル名 */
String name;
/** インデックス */
List<Index> indexes = new ArrayList<>();
/** テーブル生成 */
public static Table create(String name, String[] columnNames){
List<Column> columns = new ArrayList<>();
for(String n : columnNames){
columns.add(new TableColumn(name, n));
}
Table t = new Table(name, columns);
tables.put(name, t);
return t;
}
/**
* テーブルオブジェクトの生成
* @param name テーブル名
* @param columns 属性
*/
private Table(String name, List<Column> columns) {
super(columns, new ArrayList<Taple>());
this.name = name;
}
@Override
public QueryObj lessThan(String columnName, Integer value) {
if(value == null){
return new Relation(getColumns(), Collections.EMPTY_LIST);
}
int idx = findColumn(columnName);
if(idx >= getColumns().size()){
return new Relation(getColumns(), Collections.EMPTY_LIST);
}
TableColumn column = (TableColumn) getColumns().get(idx);
if(column.treeIndex != null){
//ツリーインデックスがあるときはツリーインデックスを使う
return column.treeIndex.lessThan(columnName, value);
}
return super.lessThan(columnName, value);
}
@Override
public QueryObj equalsTo(String columnName, Object value) {
if(value == null){
return new Relation(getColumns(), Collections.EMPTY_LIST);
}
int idx = findColumn(columnName);
if(idx >= getColumns().size()){
return new Relation(getColumns(), Collections.EMPTY_LIST);
}
TableColumn column = (TableColumn) getColumns().get(idx);
if(column.hashIndex != null){
//ハッシュインデックスがあるならハッシュインデックス
return column.hashIndex.equalsTo(columnName, value);
}else if(column.treeIndex != null){
//ツリーインデックスがあるならツリーインデックス
return column.treeIndex.equalsTo(columnName, value);
}
return super.equalsTo(columnName, value);
}
@Override
public QueryObj between(String columnName, Integer lower, Integer upper) {
if(lower == null || upper == null){
return new Relation(getColumns(), Collections.EMPTY_LIST);
}
int idx = findColumn(columnName);
if(idx >= getColumns().size()){
return new Relation(getColumns(), Collections.EMPTY_LIST);
}
TableColumn column = (TableColumn) getColumns().get(idx);
if(column.treeIndex != null){
//ツリーインデックスがあるときはツリーインデックスを使う
return column.treeIndex.between(columnName, lower, upper);
}
return super.between(columnName, lower, upper);
}
@Override
public QueryObj orderBy(String columnName, boolean asc) {
int idx = findColumn(columnName);
if(idx >= getColumns().size()){
return this;
}
TableColumn column = (TableColumn) getColumns().get(idx);
if(column.treeIndex != null){
//ツリーインデックスがあるときはツリーインデックスを使う
return column.treeIndex.orderBy(columnName, asc);
}
return super.orderBy(columnName, asc);
}
@Override
public QueryObj groupBy(String columnName, Aggregation... aggregations) {
int idx = findColumn(columnName);
if(idx >= getColumns().size()){
return super.groupBy(columnName, aggregations);
}
TableColumn column = (TableColumn) getColumns().get(idx);
Index index = column.treeIndex;
if(index == null){
index = column.hashIndex;
}
if(index != null){
//インデックスがあるならインデックスを使って集計
return index.groupBy(columnName, aggregations);
}
return super.groupBy(columnName, aggregations);
}
/**
* タプルの追加
* @param values 値
* @return
*/
public Table insert(Object... values){
++currentOid;
Taple taple = new TableTaple(currentOid, this, Arrays.asList(values));
getTaples().add(taple);
for(Index index : indexes){
index.insert(taple);
}
return this;
}
/**
* インデックス追加
* @param columnName フィールド名
* @param type インデックス種別
*/
public Index addIndex(String columnName, IndexType type){
int idx = findColumn(columnName);
TableColumn col = (TableColumn) getColumns().get(idx);
Index index;
if(type == IndexType.TREE){
if(col.treeIndex == null){
index = new TreeIndex(this, col, idx);
col.treeIndex = (TreeIndex) index;
}else{
return col.treeIndex;
}
}else if(type == IndexType.HASH){
if(col.hashIndex == null){
index = new HashIndex(this, col, idx);
col.hashIndex = (HashIndex) index;
}else{
return col.hashIndex;
}
}else{
return null;
}
indexes.add(index);
//すでに存在するデータをインデックスに追加
for(Taple tp : getTaples()){
index.insert(tp);
}
return index;
}
private void execDelete(Taple tp) {
getTaples().remove(tp);
for(Index index : indexes){
index.delete(tp);
}
}
private void execUpdate(Taple tp, UpdateOperation[] op) {
if(op.length == 0) return;
List<UpdatedField> updated = new ArrayList<>();
for(UpdateOperation uo : op){
int idx = findColumn(uo.tapleName);
if(idx >= getColumns().size()) continue;
Object oldValue = tp.values.size() <= idx ? null : tp.values.get(idx);
Object newValue = uo.eval(oldValue);
if((oldValue == null && newValue != null) || (oldValue != null && !oldValue.equals(newValue))){
//値がかわった
//値を埋める
while(tp.values.size() <= idx){
tp.values.add(null);
}
//値の変更
tp.values.set(idx, newValue);
//変更の記録
updated.add(new UpdatedField(uo.tapleName, idx, oldValue, newValue));
}
//同じフィールドに対する変更のチェックは行っていない
}
if(!updated.isEmpty()){
//変更があるならインデックスに反映
for(Index index : indexes){
index.update(tp, updated);
}
}
}
}
/** タプル */
public static class Taple{
/** 保持する値 */
List<Object> values;
public Taple(List<Object> values) {
this.values = values;
}
}
/** テーブルのタプル */
public static class TableTaple extends Taple{
Table parent;
long oid;
public TableTaple(long oid, Table parent, List<Object> values) {
super(values);
this.oid = oid;
this.parent = parent;
}
}
/** 属性 */
public static class Column{
/** テーブルなどの名前 */
String parent;
/** 属性名 */
String name;
public Column(String parent, String name) {
this.parent = parent;
this.name = name;
}
public Column(String name) {
this("", name);
}
}
/** テーブルのカラム定義 */
public static class TableColumn extends Column{
HashIndex hashIndex;
TreeIndex treeIndex;
public TableColumn(String parent, String name) {
super(parent, name);
}
}
/** インデックス種別 */
public static enum IndexType{
TREE,
HASH
}
/** インデックス */
public static abstract class Index extends AbstractRelation{
Relation parent;
Column belongs;
int colIndex;
public Index(Relation parent, Column belongs, int colIndex) {
this.parent = parent;
this.belongs = belongs;
this.colIndex = colIndex;
}
@Override
public List<Column> getColumns() {
return parent.getColumns();
}
public abstract void insert(Taple taple);
public abstract void delete(Taple taple);
public abstract void update(Taple newtaple, List<UpdatedField> updated);
}
public static class UpdatedField{
String columnName;
int columnIndex;
Object oldValue;
Object newValue;
public UpdatedField(String columnName, int columnIndex, Object oldValue, Object newValue) {
this.columnName = columnName;
this.columnIndex = columnIndex;
this.oldValue = oldValue;
this.newValue = newValue;
}
}
public static abstract class MapIndex extends Index{
Map<Object, List<Taple>> indexed;
public MapIndex(Relation parent, Column belongs, int colIndex, Map<Object, List<Taple>> indexed) {
super(parent, belongs, colIndex);
this.indexed = indexed;
}
@Override
public void insert(Taple taple) {
Object value = taple.values.get(colIndex);
if(value == null){
//null値にはインデックスはない
return;
}
List<Taple> taples = indexed.get(value);
if(taples == null){
taples = new ArrayList<>();
indexed.put(value, taples);
}
taples.add(taple);
}
@Override
public void delete(Taple taple) {
//インデックス対象フィールドの確認
if(taple.values.size() <= colIndex) return;
Object value = taple.values.get(colIndex);
removeValue(value, taple);
}
@Override
public void update(Taple newtaple, List<UpdatedField> updated) {
for(UpdatedField uf : updated){
if(uf.columnIndex == colIndex){
//インデックス対象行の変更の場合
removeValue(uf.oldValue, newtaple);
insert(newtaple);
}
}
}
/** 値にひもづけられた行を削除 */
private void removeValue(Object value, Taple taple) {
if(value == null) return;
//インデックスに格納されている行を取得
List<Taple> list = indexed.get(value);
if (list == null) {
System.out.println("なぜか" + value + "がインデックスにない");
return;
}
//インデックスから削除
list.remove(taple);
if(list.isEmpty()){
indexed.remove(value);
}
}
@Override
public List<Taple> getTaples() {
return flatten(indexed.values());
}
@Override
public QueryObj equalsTo(String columnName, Object value) {
List<Taple> taples = indexed.get(value);
if(taples == null){
return new Relation(getColumns(), Collections.EMPTY_LIST);
}
return new Relation(getColumns(), taples);
}
@Override
public QueryObj groupBy(String columnName, Aggregation... aggregations) {
//カラム作成
List<Column> newColumns = new ArrayList<>();
newColumns.add(new Column(columnName));
List<Integer> colIndexes = new ArrayList<>();
for(Aggregation agg : aggregations){
newColumns.add(new Column(agg.getName()));
colIndexes.add(findColumn(agg.columnName));
}
//集計
List<Taple> taples = new ArrayList<>();
for(Map.Entry<Object, List<Taple>> me : indexed.entrySet()){
List<Object> values = new ArrayList<>();
//集計対象行
values.add(me.getKey());
//一旦集計をリセット
for(Aggregation agg : aggregations){
agg.reset();
}
//集計
for(Taple tp : me.getValue()){
for(int i = 0; i < colIndexes.size(); ++i){
int idx = colIndexes.get(i);
if(idx >= tp.values.size()) continue;
Object value = tp.values.get(idx);
if(value == null) continue;
Aggregation ag = aggregations[i];
ag.addData(value);
}
}
//結果の格納
for(Aggregation agg : aggregations){
values.add(agg.getResult());
}
taples.add(new Taple(values));
}
return new Relation(newColumns, taples);
}
/**
* リストのリストを平坦にする
* @param taples
* @return
*/
List<Taple> flatten(Collection<List<Taple>> taples){
List<Taple> result = new ArrayList<>();
for(List<Taple> vl : taples){
for(Taple tp : vl){
result.add(tp);
}
}
return result;
}
}
/** ツリーインデックス */
public static class TreeIndex extends MapIndex{
public TreeIndex(Relation parent, Column belongs, int colIndex) {
super(parent, belongs, colIndex, new TreeMap<Object, List<Taple>>());
}
@Override
public QueryObj lessThan(String columnName, Integer value) {
TreeMap<Object, List<Taple>> tindexed = (TreeMap<Object, List<Taple>>) indexed;
NavigableMap<Object, List<Taple>> headMap = tindexed.headMap(value, false);
return new Relation(getColumns(), flatten(headMap.values()));
}
@Override
public QueryObj between(String columnName, Integer lower, Integer upper) {
TreeMap<Object, List<Taple>> tindexed = (TreeMap<Object, List<Taple>>) indexed;
NavigableMap<Object, List<Taple>> betweenMap = tindexed.subMap(lower, true, upper, true);
return new Relation(getColumns(), flatten(betweenMap.values()));
}
@Override
public QueryObj orderBy(String columnName, boolean asc) {
Collection<List<Taple>> values;
if(asc){
values = indexed.values();
}else{
TreeMap<Object, List<Taple>> tindexed = (TreeMap<Object, List<Taple>>) indexed;
values = tindexed.descendingMap().values();
}
return new Relation(getColumns(), flatten(values));
}
}
/** ハッシュインデックス */
public static class HashIndex extends MapIndex{
public HashIndex(Relation parent, Column belongs, int colIndex) {
super(parent, belongs, colIndex, new LinkedHashMap<Object, List<Taple>>());
}
}
}
@kishida
Copy link
Author

kishida commented Aug 18, 2012

勉強用のかわいいデータベース
http://d.hatena.ne.jp/nowokay/20120817#1345197962

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment