How to use

TableImpl

in

com.ohmdb.impl

@Override
@SuppressWarnings("unchecked")
public synchronized <T> Table<T> table(Class<T> clazz) {
  Table<T> table = (Table<T>) tables.get(clazz);
  if (table == null) {
    table = new TableImpl<T>(this, clazz, store, ids, transactor, stats, lockManager);
    tables.put(clazz, table);
    for (Triggering<?> triggering : triggers) {
      registerTriggers(triggering, table);
    }
  }
  return table;
}

@Override
public void update(long id, Map<String, Object> properties) {
  try {
    // WRITE LOCK
    locker.globalWriteLock();
    checkId(id);
    // RUN INSIDE TRANSACTION
    DatastoreTransaction tx = getTransaction();
    E entity = get_(id);
    for (Entry<String, Object> entry : properties.entrySet()) {
      String col = entry.getKey();
      checkColumn(col);
      colInfo(col).set(entity, entry.getValue());
    }
    doUpdate(id, tx, entity);
    // FINISH INSIDE TRANSACTION
    finishTransaction(tx);
  } finally {
    // WRITE UNLOCK
    locker.globalWriteUnlock();
  }
}

@Override
public void createIndexOnNamed(String propertyName) {
  createIndexOnNamed(propertyName, new Transformer<Object>() {
    @Override
    public Object transform(Object value) {
      return value;
    }
  });
}

@Override
public void delete(long id) {
  try {
    // WRITE LOCK
    locker.globalWriteLock();
    checkId(id);
    // RUN INSIDE TRANSACTION
    DatastoreTransaction tx = getTransaction();
    deleteInTx(tx, id);
    // FINISH INSIDE TRANSACTION
    finishTransaction(tx);
  } finally {
    // WRITE UNLOCK
    locker.globalWriteUnlock();
  }
}

@Override
public void update(long id, E entity) {
  try {
    // WRITE LOCK
    locker.globalWriteLock();
    checkId(id);
    // RUN INSIDE TRANSACTION
    DatastoreTransaction tx = getTransaction();
    doUpdate(id, tx, entity);
    // FINISH INSIDE TRANSACTION
    finishTransaction(tx);
  } finally {
    // WRITE UNLOCK
    locker.globalWriteUnlock();
  }
}

@Override
public void clear() {
  try {
    // WRITE LOCK
    locker.globalWriteLock();
    // RUN INSIDE TRANSACTION
    DatastoreTransaction tx = getTransaction();
    long[] allIds = ids();
    for (long id : allIds) {
      deleteInTx(tx, id);
    }
    // FINISH INSIDE TRANSACTION
    finishTransaction(tx);
  } finally {
    // WRITE UNLOCK
    locker.globalWriteUnlock();
  }
}

@Override
public void fill(long id, String columnName, Object value) {
  boolean shouldInsert = !idColl.has(id);
  // System.out.println("FILL " + id + " COL=" + columnName + " VAL=" +
  // value + " INS=" + shouldInsert);
  int row;
  if (shouldInsert) {
    idColl.registerId(id);
    row = rows++;
    idColl.set(id, new IdAddress(this, row));
    size++;
    records.add(newEntity());
    ids.add(id);
  } else {
    row = row(id);
  }
  checkId(id);
  checkColumn(columnName);
  PropertyInfo prop = colInfo(columnName);
  Column column = prop.getColumn();
  column.set(row, value);
}

@Override
public E get(long id) {
  try {
    // READ LOCK
    locker.globalReadLock();
    checkId(id);
    insider.getting(clazz, id);
    E entity = newEntity();
    doTriggers(beforeRead, TriggerAction.BEFORE_READ, id, null, entity);
    get_(id, entity);
    doTriggers(afterRead, TriggerAction.AFTER_READ, id, null, entity);
    insider.got(clazz, id, entity);
    return entity;
  } finally {
    // READ UNLOCK
    locker.globalReadUnlock();
  }
}

private void deleteInTx(DatastoreTransaction tx, long id) {
  insider.deleting(clazz, id);
  E entity = get_(id);
  doTriggers(beforeDelete, TriggerAction.BEFORE_DELETE, id, entity, null);
  stats.deletes++;
  int row = row(id);
  // TODO check - changelog if not deleted rels?
  db.deleteRelsInTx(id, tx); // CHANGE #1
  size--; // CHANGE #2
  deletedCount++; // CHANGE #3
  currentlyDeleted.add(row); // CHANGE #4
  idColl.delete(id); // CHANGE #5
  ids.remove(id); // CHANGE #6
  changelog.add(TableChange.delete(id, row)); // CHANGELOG
  // TODO also delete old (renamed) columns?
  for (PropertyInfo prop : props) {
    deleteCell(tx, id, row, prop);
  }
  doTriggers(afterDelete, TriggerAction.AFTER_DELETE, id, entity, null);
  insider.deleted(clazz, id);
}

@Override
public void load(long id, E entity) {
  try {
    // READ LOCK
    locker.globalReadLock();
    checkId(id);
    insider.getting(clazz, id);
    doTriggers(beforeRead, TriggerAction.BEFORE_READ, id, null, entity);
    get_(id, entity);
    doTriggers(afterRead, TriggerAction.AFTER_READ, id, null, entity);
    insider.got(clazz, id, entity);
  } finally {
    // READ UNLOCK
    locker.globalReadUnlock();
  }
}

private Object readCell(long id, String col) {
  int row = row(id);
  Column column = colInfo(col).getColumn();
  return column.get(row);
}

private void finishTransaction(DatastoreTransaction tx) {
  Transaction transaction = transactor.getTransaction();
  if (transaction == null) {
    try {
      tx.commit();
      commit();
    } catch (Exception e) {
      System.out.println(" === EXCEPTION IN TRANSACTION: ===");
      e.printStackTrace();
      System.out.println(" === ROLLING BACK... ===");
      rollback();
    }
  }
}

@Override
public Object read(long id, String col) {
  try {
    // READ LOCK
    locker.globalReadLock();
    checkId(id);
    insider.reading(clazz, id, col);
    Object value = readCell(id, col);
    insider.read(clazz, id, col, value);
    return value;
  } finally {
    // READ UNLOCK
    locker.globalReadUnlock();
  }
}

@Override
public <T> CustomIndex<E, T> multiIndex(Mapper<E, T[]> mapper, Object... properties) {
  try {
    // WRITE LOCK
    locker.globalWriteLock();
    return complexIndex(properties, mapper);
  } finally {
    // WRITE UNLOCK
    locker.globalWriteUnlock();
  }
}

private void init() {
  for (PropertyInfo prop : props) {
    // ContainerName names = ContainerName.classAndColumnName(clazz,
    // prop.getName());
    prop.setColumn(createColumn(prop));
  }
  for (PropertyInfo prop : props) {
    jokerator.encode(queryHelper, prop);
  }
}

private Index indexOf(String column) {
  Index index = colInfo(column).getIndex();
  Check.state(index != null, "The column %s doesn't have index!", column);
  return index;
}

@Override
public void update(long id, E entity) {
  try {
    // WRITE LOCK
    locker.globalWriteLock();
    checkId(id);
    // RUN INSIDE TRANSACTION
    DatastoreTransaction tx = getTransaction();
    doUpdate(id, tx, entity);
    // FINISH INSIDE TRANSACTION
    finishTransaction(tx);
  } finally {
    // WRITE UNLOCK
    locker.globalWriteUnlock();
  }
}

@Override
public void fill(long id, String columnName, Object value) {
  boolean shouldInsert = !idColl.has(id);
  // System.out.println("FILL " + id + " COL=" + columnName + " VAL=" +
  // value + " INS=" + shouldInsert);
  int row;
  if (shouldInsert) {
    idColl.registerId(id);
    row = rows++;
    idColl.set(id, new IdAddress(this, row));
    size++;
    records.add(newEntity());
    ids.add(id);
  } else {
    row = row(id);
  }
  checkId(id);
  checkColumn(columnName);
  PropertyInfo prop = colInfo(columnName);
  Column column = prop.getColumn();
  column.set(row, value);
}

@Override
public void delete(long id) {
  try {
    // WRITE LOCK
    locker.globalWriteLock();
    checkId(id);
    // RUN INSIDE TRANSACTION
    DatastoreTransaction tx = getTransaction();
    deleteInTx(tx, id);
    // FINISH INSIDE TRANSACTION
    finishTransaction(tx);
  } finally {
    // WRITE UNLOCK
    locker.globalWriteUnlock();
  }
}

@Override
public void clear() {
  try {
    // WRITE LOCK
    locker.globalWriteLock();
    // RUN INSIDE TRANSACTION
    DatastoreTransaction tx = getTransaction();
    long[] allIds = ids();
    for (long id : allIds) {
      deleteInTx(tx, id);
    }
    // FINISH INSIDE TRANSACTION
    finishTransaction(tx);
  } finally {
    // WRITE UNLOCK
    locker.globalWriteUnlock();
  }
}