@Override protected boolean hasAnotherFacet(Ice.Identity ident, String facet) { _deactivateController.lock(); try { java.util.Map<String, ObjectStore> storeMapCopy; synchronized (this) { storeMapCopy = new java.util.HashMap<String, ObjectStore>(_storeMap); } TransactionI tx = beforeQuery(); for (java.util.Map.Entry<String, ObjectStore> entry : storeMapCopy.entrySet()) { // // Do not check this facet again // if (!facet.equals(entry.getKey())) { ObjectStore store = entry.getValue(); if (tx == null && store.cache().getIfPinned(ident) != null) { return true; } if (store.dbHasObject(ident, tx)) { return true; } } } return false; } finally { _deactivateController.unlock(); } }
@Override public boolean hasFacet(Ice.Identity ident, String facet) { checkIdentity(ident); if (facet == null) { facet = ""; } _deactivateController.lock(); try { ObjectStore store = findStore(facet, false); if (store == null) { return false; } TransactionI tx = beforeQuery(); if (tx == null) { EvictorElement element = (EvictorElement) store.cache().getIfPinned(ident); if (element != null) { return true; } return store.dbHasObject(ident, null); } else { return store.dbHasObject(ident, tx); } } finally { _deactivateController.unlock(); } }
/** Tests partition operations */ @Test public void testPartitionOps() throws MetaException, InvalidObjectException, NoSuchObjectException, InvalidInputException { Database db1 = new Database(DB1, "description", "locationurl", null); objectStore.createDatabase(db1); StorageDescriptor sd = new StorageDescriptor( null, "location", null, null, false, 0, new SerDeInfo("SerDeName", "serializationLib", null), null, null, null); HashMap<String, String> tableParams = new HashMap<String, String>(); tableParams.put("EXTERNAL", "false"); FieldSchema partitionKey1 = new FieldSchema("Country", "String", ""); FieldSchema partitionKey2 = new FieldSchema("State", "String", ""); Table tbl1 = new Table( TABLE1, DB1, "owner", 1, 2, 3, sd, Arrays.asList(partitionKey1, partitionKey2), tableParams, "viewOriginalText", "viewExpandedText", "MANAGED_TABLE"); objectStore.createTable(tbl1); HashMap<String, String> partitionParams = new HashMap<String, String>(); partitionParams.put("PARTITION_LEVEL_PRIVILEGE", "true"); List<String> value1 = Arrays.asList("US", "CA"); Partition part1 = new Partition(value1, DB1, TABLE1, 111, 111, sd, partitionParams); objectStore.addPartition(part1); List<String> value2 = Arrays.asList("US", "MA"); Partition part2 = new Partition(value2, DB1, TABLE1, 222, 222, sd, partitionParams); objectStore.addPartition(part2); Deadline.startTimer("getPartition"); List<Partition> partitions = objectStore.getPartitions(DB1, TABLE1, 10); Assert.assertEquals(2, partitions.size()); Assert.assertEquals(111, partitions.get(0).getCreateTime()); Assert.assertEquals(222, partitions.get(1).getCreateTime()); objectStore.dropPartition(DB1, TABLE1, value1); partitions = objectStore.getPartitions(DB1, TABLE1, 10); Assert.assertEquals(1, partitions.size()); Assert.assertEquals(222, partitions.get(0).getCreateTime()); objectStore.dropPartition(DB1, TABLE1, value2); objectStore.dropTable(DB1, TABLE1); objectStore.dropDatabase(DB1); }
private String createArray(Object[] objArray) { String out = "<array type=\"objref\">"; ObjectStore objStore = ObjectStore.getInstance(); for (Object o : objArray) { String ref = objStore.add(o); out += this.createObjRef(ref); } out += "</array>"; return out; }
@Override public Table markPartitionForEvent( String dbName, String tblName, Map<String, String> partVals, PartitionEventType evtType) throws MetaException, UnknownTableException, InvalidPartitionException, UnknownPartitionException { return objectStore.markPartitionForEvent(dbName, tblName, partVals, evtType); }
@Override public boolean isPartitionMarkedForEvent( String dbName, String tblName, Map<String, String> partName, PartitionEventType evtType) throws MetaException, UnknownTableException, InvalidPartitionException, UnknownPartitionException { return objectStore.isPartitionMarkedForEvent(dbName, tblName, partName, evtType); }
@Override public boolean deletePartitionColumnStatistics( String dbName, String tableName, String partName, List<String> partVals, String colName) throws NoSuchObjectException, MetaException, InvalidObjectException, InvalidInputException { return objectStore.deletePartitionColumnStatistics( dbName, tableName, partName, partVals, colName); }
/** Test that transactions can be aborted */ public void testAbortTransactions() throws Exception { Address address1 = new Address(); address1.setAddress("Address 3"); Address address2 = new Address(); address2.setAddress("Address 4"); Query q = new Query(); QueryClass qcAddress = new QueryClass(Address.class); QueryField qf = new QueryField(qcAddress, "address"); ConstraintSet cs1 = new ConstraintSet(ConstraintOp.OR); cs1.addConstraint(new SimpleConstraint(qf, ConstraintOp.MATCHES, new QueryValue("Address%"))); q.addToSelect(qcAddress); q.addFrom(qcAddress); q.addToOrderBy(qf); q.setConstraint(cs1); Results res = writer.execute(q); assertEquals(res.toString(), 0, res.size()); res = realOs.execute(q); assertEquals(res.toString(), 0, res.size()); writer.beginTransaction(); assertTrue(writer.isInTransaction()); writer.store(address1); writer.store(address2); // TODO: These lines now fail, because we do not allow querying on writers with uncommitted // data. The writer should relax this restriction. res = writer.execute(q); assertEquals(2, res.size()); res = realOs.execute(q); assertEquals(res.toString(), 0, res.size()); writer.abortTransaction(); assertFalse(writer.isInTransaction()); // Should be nothing there unless we commit res = writer.execute(q); assertEquals(res.toString(), 0, res.size()); res = realOs.execute(q); assertEquals(res.toString(), 0, res.size()); }
@Override public boolean commitTransaction() { if (shouldCommitSucceed) { return objectStore.commitTransaction(); } else { return false; } }
private void writeObject(ObjectOutputStream out) throws IOException { out.defaultWriteObject(); // Serialize local snapshots cache if (!isUsingSharedSnapshotCache()) { out.writeObject(objectStore.getDataRowCache()); } }
/** Test that transactions do actually commit and that isInTransaction() works. */ public void testCommitTransactions() throws Exception { Address address1 = new Address(); address1.setAddress("Address 1"); Address address2 = new Address(); address2.setAddress("Address 2"); Query q = new Query(); QueryClass qcAddress = new QueryClass(Address.class); QueryField qf = new QueryField(qcAddress, "address"); ConstraintSet cs1 = new ConstraintSet(ConstraintOp.OR); cs1.addConstraint(new SimpleConstraint(qf, ConstraintOp.MATCHES, new QueryValue("Address%"))); q.addToSelect(qcAddress); q.addFrom(qcAddress); q.addToOrderBy(qf); q.setConstraint(cs1); try { writer.beginTransaction(); assertTrue(writer.isInTransaction()); writer.store(address1); writer.store(address2); // Should be nothing in OS until we commit Results res = realOs.execute(q); assertEquals(0, res.size()); // However, they should be in the WRITER. // TODO: These lines now fail, because we do not allow querying on writers with uncommitted // data. The writer should relax this restriction. res = writer.execute(q); assertEquals(2, res.size()); writer.commitTransaction(); assertFalse(writer.isInTransaction()); res = realOs.execute(q); assertEquals(2, res.size()); assertEquals(address1, (Address) ((ResultsRow) res.get(0)).get(0)); assertEquals(address2, (Address) ((ResultsRow) res.get(1)).get(0)); } finally { writer.delete(address1); writer.delete(address2); } }
synchronized Ice.Object evict(Ice.Identity ident, ObjectStore store) { EvictorElement element = (EvictorElement) store.cache().unpin(ident); if (element != null) { element.evict(false); return element.servant; } return null; }
/** * Creates a new DataContext with parent DataChannel and ObjectStore. * * @since 1.2 */ public DataContext(DataChannel channel, ObjectStore objectStore) { // inject self as parent context if (objectStore != null) { this.objectStore = objectStore; objectStore.setContext(this); } if (channel != null) { attachToChannel(channel); } if (objectStore != null) { DataDomain domain = getParentDataDomain(); this.usingSharedSnaphsotCache = domain != null && objectStore.getDataRowCache() == domain.getSharedSnapshotCache(); } }
/** * If the parent channel is a DataContext, reverts local changes to make this context look like * the parent, if the parent channel is a DataDomain, reverts all changes. * * @since 1.2 */ @Override public void rollbackChangesLocally() { if (objectStore.hasChanges()) { GraphDiff diff = getObjectStore().getChanges(); getObjectStore().objectsRolledBack(); fireDataChannelRolledback(this, diff); } }
@Override public List<HiveObjectPrivilege> listPrincipalTableColumnGrants( String principalName, PrincipalType principalType, String dbName, String tableName, String columnName) { return objectStore.listPrincipalTableColumnGrants( principalName, principalType, dbName, tableName, columnName); }
@Override public List<MPartitionPrivilege> listPrincipalPartitionGrants( String principalName, PrincipalType principalType, String dbName, String tableName, String partName) { return objectStore.listPrincipalPartitionGrants( principalName, principalType, dbName, tableName, partName); }
@Override public Partition getPartitionWithAuth( String dbName, String tblName, List<String> partVals, String userName, List<String> groupNames) throws MetaException, NoSuchObjectException, InvalidObjectException { return objectStore.getPartitionWithAuth(dbName, tblName, partVals, userName, groupNames); }
/** Run a dummy request on the current transaction to extends its validity. */ public void ping() { final Store randomStore = stores.iterator().next(); final ObjectStore pingObjectStore = getObjectStore(randomStore); pingObjectStore .get(0) .addCallback( new AsyncCallback<Request>() { @Override public void onFailure(Throwable caught) { Log.trace("IndexedDB PING failed", caught); } @Override public void onSuccess(Request result) { Log.trace("IndexedDB PING successful"); } }); }
/** Test database operations */ @Test public void testDatabaseOps() throws MetaException, InvalidObjectException, NoSuchObjectException { Database db1 = new Database(DB1, "description", "locationurl", null); Database db2 = new Database(DB2, "description", "locationurl", null); objectStore.createDatabase(db1); objectStore.createDatabase(db2); List<String> databases = objectStore.getAllDatabases(); Assert.assertEquals(2, databases.size()); Assert.assertEquals(DB1, databases.get(0)); Assert.assertEquals(DB2, databases.get(1)); objectStore.dropDatabase(DB1); databases = objectStore.getAllDatabases(); Assert.assertEquals(1, databases.size()); Assert.assertEquals(DB2, databases.get(0)); objectStore.dropDatabase(DB2); }
@Before public void setUp() throws Exception { HiveConf conf = new HiveConf(); conf.setVar( HiveConf.ConfVars.METASTORE_EXPRESSION_PROXY_CLASS, MockPartitionExpressionProxy.class.getName()); objectStore = new ObjectStore(); objectStore.setConf(conf); dropAllStoreObjects(objectStore); }
@Override public boolean grantRole( Role role, String userName, PrincipalType principalType, String grantor, PrincipalType grantorType, boolean grantOption) throws MetaException, NoSuchObjectException, InvalidObjectException { return objectStore.grantRole(role, userName, principalType, grantor, grantorType, grantOption); }
@Override public boolean getPartitionsByExpr( String dbName, String tblName, byte[] expr, String defaultPartitionName, short maxParts, List<Partition> result) throws TException { return objectStore.getPartitionsByExpr( dbName, tblName, expr, defaultPartitionName, maxParts, result); }
@Override public PrincipalPrivilegeSet getColumnPrivilegeSet( String dbName, String tableName, String partitionName, String columnName, String userName, List<String> groupNames) throws InvalidObjectException, MetaException { return objectStore.getColumnPrivilegeSet( dbName, tableName, partitionName, columnName, userName, groupNames); }
@Override public List<Partition> listPartitionsPsWithAuth( String dbName, String tblName, List<String> partVals, short maxParts, String userName, List<String> groupNames) throws MetaException, InvalidObjectException, NoSuchObjectException { return objectStore.listPartitionsPsWithAuth( dbName, tblName, partVals, maxParts, userName, groupNames); }
@Override public List<HiveObjectPrivilege> listPrincipalPartitionColumnGrants( String principalName, PrincipalType principalType, String dbName, String tableName, List<String> partVals, String partName, String columnName) { return objectStore.listPrincipalPartitionColumnGrants( principalName, principalType, dbName, tableName, partVals, partName, columnName); }
private Ice.Object loadCachedServant(Ice.Identity ident, ObjectStore store) { for (; ; ) { EvictorElement element = (EvictorElement) store.cache().pin(ident); if (element == null) { return null; } synchronized (this) { if (element.stale) { // // try again // continue; } element.fixEvictPosition(); // // if _evictorSize is 0, I may evict myself ... no big deal // evict(); if (_trace >= 3) { _communicator .getLogger() .trace( "Freeze.Evictor", "loaded \"" + _communicator.identityToString(ident) + "\" with facet \"" + store.facet() + "\" into the cache"); } return element.servant; } } }
// serialization support private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { // TODO: most of this should be in the superclass, especially the code // connecting // super transient ivars // read non-transient properties in.defaultReadObject(); // deserialize local snapshots cache if (!isUsingSharedSnapshotCache()) { DataRowStore cache = (DataRowStore) in.readObject(); objectStore.setDataRowCache(cache); } // CayenneDataObjects have a transient DataContext // because at deserialize time the datacontext may need to be different // than the one at serialize time (for programmer defined reasons). // So, when a DataObject is resurrected because it's DataContext was // serialized, it will then set the objects DataContext to the correct // one // If deserialized "otherwise", it will not have a DataContext. synchronized (getObjectStore()) { Iterator<?> it = objectStore.getObjectIterator(); while (it.hasNext()) { Persistent object = (Persistent) it.next(); object.setObjectContext(this); } } // ... deferring initialization of transient properties of this context // till first // access, so that it can attach to Cayenne runtime using appropriate // thread // injector. }
void associate( ObjectStore store, com.sleepycat.db.Transaction txn, boolean createDb, boolean populateIndex) throws com.sleepycat.db.DatabaseException, java.io.FileNotFoundException { assert (txn != null); _store = store; _dbName = EvictorI.indexPrefix + store.dbName() + "." + _name; com.sleepycat.db.SecondaryConfig config = new com.sleepycat.db.SecondaryConfig(); config.setAllowCreate(createDb); config.setAllowPopulate(populateIndex); config.setSortedDuplicates(true); config.setType(com.sleepycat.db.DatabaseType.BTREE); config.setKeyCreator(this); Ice.Properties properties = store.evictor().communicator().getProperties(); String propPrefix = "Freeze.Evictor." + store.evictor().filename() + "."; int btreeMinKey = properties.getPropertyAsInt(propPrefix + _dbName + ".BtreeMinKey"); if (btreeMinKey > 2) { if (store.evictor().trace() >= 1) { store .evictor() .communicator() .getLogger() .trace( "Freeze.Evictor", "Setting \"" + store.evictor().filename() + "." + _dbName + "\"'s btree minkey to " + btreeMinKey); } config.setBtreeMinKey(btreeMinKey); } boolean checksum = properties.getPropertyAsInt(propPrefix + "Checksum") > 0; if (checksum) { // // No tracing // config.setChecksum(true); } // // Can't change page size // _db = _store .evictor() .dbEnv() .getEnv() .openSecondaryDatabase(txn, _store.evictor().filename(), _dbName, _store.db(), config); }
public void testWriteBatchingAndGetObject() throws Exception { Address address1 = new Address(); address1.setAddress("Address 1"); writer.flushObjectById(); realOs.flushObjectById(); try { writer.beginTransaction(); writer.store(address1); assertNotNull(writer.getObjectById(address1.getId(), Address.class)); } finally { if (writer.isInTransaction()) { writer.abortTransaction(); } } }
ServantHolder(Ice.Current current, ObjectStore store) { _current = current; _store = store; ServantHolder sh = findServantHolder(_current.id, _store); if (sh != null) { if (!sh._removed) { _rec = sh._rec; _readOnly = sh._readOnly; if (_trace >= 3) { _communicator .getLogger() .trace( "Freeze.Evictor", "found \"" + _communicator.identityToString(_current.id) + "\" with facet \"" + _store.facet() + "\" in current context"); } } } else { // // Let's load this servant // _rec = store.load(current.id, _tx); if (_rec != null) { if (_trace >= 3) { _communicator .getLogger() .trace( "Freeze.Evictor", "loaded \"" + _communicator.identityToString(_current.id) + "\" with facet \"" + _store.facet() + "\" into current context"); } _stack.push(this); _ownServant = true; } } }