Examples with ODatabaseDocumentInternal com.orientechnologies.orient.core.db.ODatabaseDocumentInternal used on opensource projects

Example 76 with ODatabaseDocumentInternal

use of com.orientechnologies.orient.core.db.ODatabaseDocumentInternal in project orientdb by orientechnologies.

the class OIndexDefinitionFactory method getServerLocale.

private static Locale getServerLocale() {
    ODatabaseDocumentInternal db = ODatabaseRecordThreadLocal.INSTANCE.get();
    OStorage storage = db.getStorage();
    OStorageConfiguration configuration = storage.getConfiguration();
    return configuration.getLocaleInstance();
}

Example 77 with ODatabaseDocumentInternal

use of com.orientechnologies.orient.core.db.ODatabaseDocumentInternal in project orientdb by orientechnologies.

the class OSBTreeRidBag method serialize.

@Override
public int serialize(byte[] stream, int offset, UUID ownerUuid) {
    for (Map.Entry<OIdentifiable, OModifiableInteger> entry : newEntries.entrySet()) {
        OIdentifiable identifiable = entry.getKey();
        assert identifiable instanceof ORecord;
        Change c = changes.get(identifiable);
        final int delta = entry.getValue().intValue();
        if (c == null)
            changes.put(identifiable, new DiffChange(delta));
        else
            c.applyDiff(delta);
    }
    newEntries.clear();
    final ORecordSerializationContext context;
    boolean remoteMode = ODatabaseRecordThreadLocal.INSTANCE.get().getStorage() instanceof OStorageProxy;
    if (remoteMode) {
        context = null;
    } else
        context = ORecordSerializationContext.getContext();
    // make sure that we really save underlying record.
    if (collectionPointer == null) {
        if (context != null) {
            final int clusterId = getHighLevelDocClusterId();
            assert clusterId > -1;
            collectionPointer = ODatabaseRecordThreadLocal.INSTANCE.get().getSbTreeCollectionManager().createSBTree(clusterId, ownerUuid);
        }
    }
    OBonsaiCollectionPointer collectionPointer;
    if (this.collectionPointer != null)
        collectionPointer = this.collectionPointer;
    else {
        collectionPointer = OBonsaiCollectionPointer.INVALID;
    }
    OLongSerializer.INSTANCE.serializeLiteral(collectionPointer.getFileId(), stream, offset);
    offset += OLongSerializer.LONG_SIZE;
    OBonsaiBucketPointer rootPointer = collectionPointer.getRootPointer();
    OLongSerializer.INSTANCE.serializeLiteral(rootPointer.getPageIndex(), stream, offset);
    offset += OLongSerializer.LONG_SIZE;
    OIntegerSerializer.INSTANCE.serializeLiteral(rootPointer.getPageOffset(), stream, offset);
    offset += OIntegerSerializer.INT_SIZE;
    // Keep this section for binary compatibility with versions older then 1.7.5
    OIntegerSerializer.INSTANCE.serializeLiteral(size, stream, offset);
    offset += OIntegerSerializer.INT_SIZE;
    if (context == null) {
        ChangeSerializationHelper.INSTANCE.serializeChanges(changes, OLinkSerializer.INSTANCE, stream, offset);
    } else {
        ODatabaseDocumentInternal db = ODatabaseRecordThreadLocal.INSTANCE.getIfDefined();
        for (Entry<OIdentifiable, Change> change : this.changes.entrySet()) {
            OIdentifiable key = change.getKey();
            if (db != null && db.getTransaction().isActive()) {
                if (!key.getIdentity().isPersistent()) {
                    OIdentifiable newKey = db.getTransaction().getRecord(key.getIdentity());
                    if (newKey != null) {
                        changes.remove(key);
                        changes.put(newKey, change.getValue());
                    }
                }
            }
        }
        this.collectionPointer = collectionPointer;
        context.push(new ORidBagUpdateSerializationOperation(changes, collectionPointer));
        // 0-length serialized list of changes
        OIntegerSerializer.INSTANCE.serializeLiteral(0, stream, offset);
        offset += OIntegerSerializer.INT_SIZE;
    }
    return offset;
}

Example 78 with ODatabaseDocumentInternal

use of com.orientechnologies.orient.core.db.ODatabaseDocumentInternal in project orientdb by orientechnologies.

the class ODatabaseCompare method compareIndexes.

@SuppressWarnings({ "unchecked", "rawtypes" })
private void compareIndexes(ODocumentHelper.RIDMapper ridMapper) {
    listener.onMessage("\nStarting index comparison:");
    boolean ok = true;
    final OIndexManager indexManagerOne = makeDbCall(databaseOne, new ODbRelatedCall<OIndexManager>() {

        public OIndexManager call(ODatabaseDocumentInternal database) {
            return database.getMetadata().getIndexManager();
        }
    });
    final OIndexManager indexManagerTwo = makeDbCall(databaseTwo, new ODbRelatedCall<OIndexManager>() {

        public OIndexManager call(ODatabaseDocumentInternal database) {
            return database.getMetadata().getIndexManager();
        }
    });
    final Collection<? extends OIndex<?>> indexesOne = makeDbCall(databaseOne, new ODbRelatedCall<Collection<? extends OIndex<?>>>() {

        public Collection<? extends OIndex<?>> call(ODatabaseDocumentInternal database) {
            return indexManagerOne.getIndexes();
        }
    });
    int indexesSizeOne = makeDbCall(databaseTwo, new ODbRelatedCall<Integer>() {

        public Integer call(ODatabaseDocumentInternal database) {
            return indexesOne.size();
        }
    });
    int indexesSizeTwo = makeDbCall(databaseTwo, new ODbRelatedCall<Integer>() {

        public Integer call(ODatabaseDocumentInternal database) {
            return indexManagerTwo.getIndexes().size();
        }
    });
    if (exportImportHashTable != null)
        indexesSizeTwo--;
    if (indexesSizeOne != indexesSizeTwo) {
        ok = false;
        listener.onMessage("\n- ERR: Amount of indexes are different.");
        listener.onMessage("\n--- DB1: " + indexesSizeOne);
        listener.onMessage("\n--- DB2: " + indexesSizeTwo);
        listener.onMessage("\n");
        ++differences;
    }
    final Iterator<? extends OIndex<?>> iteratorOne = makeDbCall(databaseOne, new ODbRelatedCall<Iterator<? extends OIndex<?>>>() {

        public Iterator<? extends OIndex<?>> call(ODatabaseDocumentInternal database) {
            return indexesOne.iterator();
        }
    });
    while (makeDbCall(databaseOne, new ODbRelatedCall<Boolean>() {

        public Boolean call(ODatabaseDocumentInternal database) {
            return iteratorOne.hasNext();
        }
    })) {
        final OIndex indexOne = makeDbCall(databaseOne, new ODbRelatedCall<OIndex<?>>() {

            public OIndex<?> call(ODatabaseDocumentInternal database) {
                return iteratorOne.next();
            }
        });
        final OIndex<?> indexTwo = makeDbCall(databaseTwo, new ODbRelatedCall<OIndex<?>>() {

            public OIndex<?> call(ODatabaseDocumentInternal database) {
                return indexManagerTwo.getIndex(indexOne.getName());
            }
        });
        if (indexTwo == null) {
            ok = false;
            listener.onMessage("\n- ERR: Index " + indexOne.getName() + " is absent in DB2.");
            ++differences;
            continue;
        }
        if (!indexOne.getType().equals(indexTwo.getType())) {
            ok = false;
            listener.onMessage("\n- ERR: Index types for index " + indexOne.getName() + " are different.");
            listener.onMessage("\n--- DB1: " + indexOne.getType());
            listener.onMessage("\n--- DB2: " + indexTwo.getType());
            listener.onMessage("\n");
            ++differences;
            continue;
        }
        if (!indexOne.getClusters().equals(indexTwo.getClusters())) {
            ok = false;
            listener.onMessage("\n- ERR: Clusters to index for index " + indexOne.getName() + " are different.");
            listener.onMessage("\n--- DB1: " + indexOne.getClusters());
            listener.onMessage("\n--- DB2: " + indexTwo.getClusters());
            listener.onMessage("\n");
            ++differences;
            continue;
        }
        if (indexOne.getDefinition() == null && indexTwo.getDefinition() != null) {
            ok = false;
            listener.onMessage("\n- ERR: Index definition for index " + indexOne.getName() + " for DB2 is not null.");
            ++differences;
            continue;
        } else if (indexOne.getDefinition() != null && indexTwo.getDefinition() == null) {
            ok = false;
            listener.onMessage("\n- ERR: Index definition for index " + indexOne.getName() + " for DB2 is null.");
            ++differences;
            continue;
        } else if (indexOne.getDefinition() != null && !indexOne.getDefinition().equals(indexTwo.getDefinition())) {
            ok = false;
            listener.onMessage("\n- ERR: Index definitions for index " + indexOne.getName() + " are different.");
            listener.onMessage("\n--- DB1: " + indexOne.getDefinition());
            listener.onMessage("\n--- DB2: " + indexTwo.getDefinition());
            listener.onMessage("\n");
            ++differences;
            continue;
        }
        final long indexOneSize = makeDbCall(databaseOne, new ODbRelatedCall<Long>() {

            public Long call(ODatabaseDocumentInternal database) {
                return indexOne.getSize();
            }
        });
        final long indexTwoSize = makeDbCall(databaseTwo, new ODbRelatedCall<Long>() {

            public Long call(ODatabaseDocumentInternal database) {
                return indexTwo.getSize();
            }
        });
        if (indexOneSize != indexTwoSize) {
            ok = false;
            listener.onMessage("\n- ERR: Amount of entries for index " + indexOne.getName() + " are different.");
            listener.onMessage("\n--- DB1: " + indexOneSize);
            listener.onMessage("\n--- DB2: " + indexTwoSize);
            listener.onMessage("\n");
            ++differences;
        }
        if (compareIndexMetadata) {
            final ODocument metadataOne = indexOne.getMetadata();
            final ODocument metadataTwo = indexTwo.getMetadata();
            if (metadataOne == null && metadataTwo != null) {
                ok = false;
                listener.onMessage("\n- ERR: Metadata for index " + indexOne.getName() + " for DB1 is null but for DB2 is not.");
                listener.onMessage("\n");
                ++differences;
            } else if (metadataOne != null && metadataTwo == null) {
                ok = false;
                listener.onMessage("\n- ERR: Metadata for index " + indexOne.getName() + " for DB1 is not null but for DB2 is null.");
                listener.onMessage("\n");
                ++differences;
            } else if (metadataOne != null && metadataTwo != null && !ODocumentHelper.hasSameContentOf(metadataOne, databaseOne, metadataTwo, databaseTwo, ridMapper)) {
                ok = false;
                listener.onMessage("\n- ERR: Metadata for index " + indexOne.getName() + " for DB1 and for DB2 are different.");
                makeDbCall(databaseOne, new ODbRelatedCall<Object>() {

                    @Override
                    public Object call(ODatabaseDocumentInternal database) {
                        listener.onMessage("\n--- M1: " + metadataOne);
                        return null;
                    }
                });
                makeDbCall(databaseTwo, new ODbRelatedCall<Object>() {

                    @Override
                    public Object call(ODatabaseDocumentInternal database) {
                        listener.onMessage("\n--- M2: " + metadataTwo);
                        return null;
                    }
                });
                listener.onMessage("\n");
                ++differences;
            }
        }
        if (((compareEntriesForAutomaticIndexes && !indexOne.getType().equals("DICTIONARY")) || !indexOne.isAutomatic())) {
            final OIndexKeyCursor indexKeyCursorOne = makeDbCall(databaseOne, new ODbRelatedCall<OIndexKeyCursor>() {

                public OIndexKeyCursor call(ODatabaseDocumentInternal database) {
                    return indexOne.keyCursor();
                }
            });
            Object key = makeDbCall(databaseOne, new ODbRelatedCall<Object>() {

                @Override
                public Object call(ODatabaseDocumentInternal database) {
                    return indexKeyCursorOne.next(-1);
                }
            });
            while (key != null) {
                final Object indexKey = key;
                Object indexOneValue = makeDbCall(databaseOne, new ODbRelatedCall<Object>() {

                    public Object call(ODatabaseDocumentInternal database) {
                        return indexOne.get(indexKey);
                    }
                });
                final Object indexTwoValue = makeDbCall(databaseTwo, new ODbRelatedCall<Object>() {

                    public Object call(ODatabaseDocumentInternal database) {
                        return indexTwo.get(indexKey);
                    }
                });
                if (indexTwoValue == null) {
                    ok = false;
                    listener.onMessage("\n- ERR: Entry with key " + key + " is absent in index " + indexOne.getName() + " for DB2.");
                    ++differences;
                } else if (indexOneValue instanceof Set && indexTwoValue instanceof Set) {
                    final Set<Object> indexOneValueSet = (Set<Object>) indexOneValue;
                    final Set<Object> indexTwoValueSet = (Set<Object>) indexTwoValue;
                    if (!ODocumentHelper.compareSets(databaseOne, indexOneValueSet, databaseTwo, indexTwoValueSet, ridMapper)) {
                        ok = false;
                        reportIndexDiff(indexOne, key, indexOneValue, indexTwoValue);
                    }
                } else if (indexOneValue instanceof ORID && indexTwoValue instanceof ORID) {
                    if (ridMapper != null && ((ORID) indexOneValue).isPersistent()) {
                        OIdentifiable identifiable = ridMapper.map((ORID) indexOneValue);
                        if (identifiable != null)
                            indexOneValue = identifiable.getIdentity();
                    }
                    if (!indexOneValue.equals(indexTwoValue)) {
                        ok = false;
                        reportIndexDiff(indexOne, key, indexOneValue, indexTwoValue);
                    }
                } else if (!indexOneValue.equals(indexTwoValue)) {
                    ok = false;
                    reportIndexDiff(indexOne, key, indexOneValue, indexTwoValue);
                }
                key = makeDbCall(databaseOne, new ODbRelatedCall<Object>() {

                    @Override
                    public Object call(ODatabaseDocumentInternal database) {
                        return indexKeyCursorOne.next(-1);
                    }
                });
            }
        }
    }
    if (ok)
        listener.onMessage("OK");
}

Example 79 with ODatabaseDocumentInternal

use of com.orientechnologies.orient.core.db.ODatabaseDocumentInternal in project orientdb by orientechnologies.

the class ODatabaseCompare method compareRecords.

@SuppressFBWarnings("NP_NULL_ON_SOME_PATH")
private boolean compareRecords(ODocumentHelper.RIDMapper ridMapper) {
    listener.onMessage("\nStarting deep comparison record by record. This may take a few minutes. Wait please...");
    Collection<String> clusterNames1 = makeDbCall(databaseOne, new ODbRelatedCall<Collection<String>>() {

        @Override
        public Collection<String> call(ODatabaseDocumentInternal database) {
            return database.getClusterNames();
        }
    });
    for (final String clusterName : clusterNames1) {
        // CHECK IF THE CLUSTER IS INCLUDED
        if (includeClusters != null) {
            if (!includeClusters.contains(clusterName))
                continue;
        } else if (excludeClusters != null) {
            if (excludeClusters.contains(clusterName))
                continue;
        }
        final int clusterId1 = makeDbCall(databaseOne, new ODbRelatedCall<Integer>() {

            @Override
            public Integer call(ODatabaseDocumentInternal database) {
                return database.getClusterIdByName(clusterName);
            }
        });
        final long[] db1Range = makeDbCall(databaseOne, new ODbRelatedCall<long[]>() {

            @Override
            public long[] call(ODatabaseDocumentInternal database) {
                return database.getStorage().getClusterDataRange(clusterId1);
            }
        });
        final long[] db2Range = makeDbCall(databaseTwo, new ODbRelatedCall<long[]>() {

            @Override
            public long[] call(ODatabaseDocumentInternal database) {
                return database.getStorage().getClusterDataRange(clusterId1);
            }
        });
        final long db1Max = db1Range[1];
        final long db2Max = db2Range[1];
        databaseOne.activateOnCurrentThread();
        final ODocument doc1 = new ODocument();
        databaseTwo.activateOnCurrentThread();
        final ODocument doc2 = new ODocument();
        final ORecordId rid = new ORecordId(clusterId1);
        // TODO why this maximums can be different?
        final long clusterMax = Math.max(db1Max, db2Max);
        final OStorage storage;
        ODatabaseDocumentInternal selectedDatabase;
        if (clusterMax == db1Max)
            selectedDatabase = databaseOne;
        else
            selectedDatabase = databaseTwo;
        OPhysicalPosition[] physicalPositions = makeDbCall(selectedDatabase, new ODbRelatedCall<OPhysicalPosition[]>() {

            @Override
            public OPhysicalPosition[] call(ODatabaseDocumentInternal database) {
                return database.getStorage().ceilingPhysicalPositions(clusterId1, new OPhysicalPosition(0));
            }
        });
        OStorageConfiguration configuration1 = makeDbCall(databaseOne, new ODbRelatedCall<OStorageConfiguration>() {

            @Override
            public OStorageConfiguration call(ODatabaseDocumentInternal database) {
                return database.getStorage().getConfiguration();
            }
        });
        OStorageConfiguration configuration2 = makeDbCall(databaseTwo, new ODbRelatedCall<OStorageConfiguration>() {

            @Override
            public OStorageConfiguration call(ODatabaseDocumentInternal database) {
                return database.getStorage().getConfiguration();
            }
        });
        String storageType1 = makeDbCall(databaseOne, new ODbRelatedCall<String>() {

            @Override
            public String call(ODatabaseDocumentInternal database) {
                return database.getStorage().getType();
            }
        });
        String storageType2 = makeDbCall(databaseTwo, new ODbRelatedCall<String>() {

            @Override
            public String call(ODatabaseDocumentInternal database) {
                return database.getStorage().getType();
            }
        });
        long recordsCounter = 0;
        while (physicalPositions.length > 0) {
            for (OPhysicalPosition physicalPosition : physicalPositions) {
                try {
                    recordsCounter++;
                    final long position = physicalPosition.clusterPosition;
                    rid.setClusterPosition(position);
                    if (rid.equals(new ORecordId(configuration1.indexMgrRecordId)) && rid.equals(new ORecordId(configuration2.indexMgrRecordId)))
                        continue;
                    if (rid.equals(new ORecordId(configuration1.schemaRecordId)) && rid.equals(new ORecordId(configuration2.schemaRecordId)))
                        continue;
                    if (rid.getClusterId() == 0 && rid.getClusterPosition() == 0) {
                        // Skip the compare of raw structure if the storage type are different, due the fact that are different by definition.
                        if (!storageType1.equals(storageType2))
                            continue;
                    }
                    final ORecordId rid2;
                    if (ridMapper == null)
                        rid2 = rid;
                    else {
                        final ORID newRid = ridMapper.map(rid);
                        if (newRid == null)
                            rid2 = rid;
                        else
                            rid2 = new ORecordId(newRid);
                    }
                    final ORawBuffer buffer1 = makeDbCall(databaseOne, new ODbRelatedCall<ORawBuffer>() {

                        @Override
                        public ORawBuffer call(ODatabaseDocumentInternal database) {
                            return database.getStorage().readRecord(rid, null, true, false, null).getResult();
                        }
                    });
                    final ORawBuffer buffer2 = makeDbCall(databaseTwo, new ODbRelatedCall<ORawBuffer>() {

                        @Override
                        public ORawBuffer call(ODatabaseDocumentInternal database) {
                            return database.getStorage().readRecord(rid2, null, true, false, null).getResult();
                        }
                    });
                    if (buffer1 == null && buffer2 == null)
                        // BOTH RECORD NULL, OK
                        continue;
                    else if (buffer1 == null && buffer2 != null) {
                        // REC1 NULL
                        listener.onMessage("\n- ERR: RID=" + clusterId1 + ":" + position + " is null in DB1");
                        ++differences;
                    } else if (buffer1 != null && buffer2 == null) {
                        // REC2 NULL
                        listener.onMessage("\n- ERR: RID=" + clusterId1 + ":" + position + " is null in DB2");
                        ++differences;
                    } else {
                        if (buffer1.recordType != buffer2.recordType) {
                            listener.onMessage("\n- ERR: RID=" + clusterId1 + ":" + position + " recordType is different: " + (char) buffer1.recordType + " <-> " + (char) buffer2.recordType);
                            ++differences;
                        }
                        if (buffer1.buffer == null && buffer2.buffer == null) {
                        } else if (buffer1.buffer == null && buffer2.buffer != null) {
                            listener.onMessage("\n- ERR: RID=" + clusterId1 + ":" + position + " content is different: null <-> " + buffer2.buffer.length);
                            ++differences;
                        } else if (buffer1.buffer != null && buffer2.buffer == null) {
                            listener.onMessage("\n- ERR: RID=" + clusterId1 + ":" + position + " content is different: " + buffer1.buffer.length + " <-> null");
                            ++differences;
                        } else {
                            if (buffer1.recordType == ODocument.RECORD_TYPE) {
                                // DOCUMENT: TRY TO INSTANTIATE AND COMPARE
                                makeDbCall(databaseOne, new ODocumentHelper.ODbRelatedCall<Object>() {

                                    public Object call(ODatabaseDocumentInternal database) {
                                        doc1.reset();
                                        doc1.fromStream(buffer1.buffer);
                                        return null;
                                    }
                                });
                                makeDbCall(databaseTwo, new ODocumentHelper.ODbRelatedCall<Object>() {

                                    public Object call(ODatabaseDocumentInternal database) {
                                        doc2.reset();
                                        doc2.fromStream(buffer2.buffer);
                                        return null;
                                    }
                                });
                                if (rid.toString().equals(configuration1.schemaRecordId) && rid.toString().equals(configuration2.schemaRecordId)) {
                                    makeDbCall(databaseOne, new ODocumentHelper.ODbRelatedCall<java.lang.Object>() {

                                        public Object call(ODatabaseDocumentInternal database) {
                                            convertSchemaDoc(doc1);
                                            return null;
                                        }
                                    });
                                    makeDbCall(databaseTwo, new ODocumentHelper.ODbRelatedCall<java.lang.Object>() {

                                        public Object call(ODatabaseDocumentInternal database) {
                                            convertSchemaDoc(doc2);
                                            return null;
                                        }
                                    });
                                }
                                if (!ODocumentHelper.hasSameContentOf(doc1, databaseOne, doc2, databaseTwo, ridMapper)) {
                                    listener.onMessage("\n- ERR: RID=" + clusterId1 + ":" + position + " document content is different");
                                    listener.onMessage("\n--- REC1: " + new String(buffer1.buffer));
                                    listener.onMessage("\n--- REC2: " + new String(buffer2.buffer));
                                    listener.onMessage("\n");
                                    ++differences;
                                }
                            } else {
                                if (buffer1.buffer.length != buffer2.buffer.length) {
                                    // CHECK IF THE TRIMMED SIZE IS THE SAME
                                    final String rec1 = new String(buffer1.buffer).trim();
                                    final String rec2 = new String(buffer2.buffer).trim();
                                    if (rec1.length() != rec2.length()) {
                                        listener.onMessage("\n- ERR: RID=" + clusterId1 + ":" + position + " content length is different: " + buffer1.buffer.length + " <-> " + buffer2.buffer.length);
                                        if (buffer1.recordType == ODocument.RECORD_TYPE)
                                            listener.onMessage("\n--- REC1: " + rec1);
                                        if (buffer2.recordType == ODocument.RECORD_TYPE)
                                            listener.onMessage("\n--- REC2: " + rec2);
                                        listener.onMessage("\n");
                                        ++differences;
                                    }
                                } else {
                                    // CHECK BYTE PER BYTE
                                    for (int b = 0; b < buffer1.buffer.length; ++b) {
                                        if (buffer1.buffer[b] != buffer2.buffer[b]) {
                                            listener.onMessage("\n- ERR: RID=" + clusterId1 + ":" + position + " content is different at byte #" + b + ": " + buffer1.buffer[b] + " <-> " + buffer2.buffer[b]);
                                            listener.onMessage("\n--- REC1: " + new String(buffer1.buffer));
                                            listener.onMessage("\n--- REC2: " + new String(buffer2.buffer));
                                            listener.onMessage("\n");
                                            ++differences;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                } catch (RuntimeException e) {
                    OLogManager.instance().error(this, "Error during data comparison of records with rid " + rid);
                    throw e;
                }
            }
            final OPhysicalPosition[] curPosition = physicalPositions;
            physicalPositions = makeDbCall(selectedDatabase, new ODbRelatedCall<OPhysicalPosition[]>() {

                @Override
                public OPhysicalPosition[] call(ODatabaseDocumentInternal database) {
                    return database.getStorage().higherPhysicalPositions(clusterId1, curPosition[curPosition.length - 1]);
                }
            });
            if (recordsCounter % 10000 == 0)
                listener.onMessage("\n" + recordsCounter + " records were processed for cluster " + clusterName + " ...");
        }
        listener.onMessage("\nCluster comparison was finished, " + recordsCounter + " records were processed for cluster " + clusterName + " ...");
    }
    return true;
}

Example 80 with ODatabaseDocumentInternal

use of com.orientechnologies.orient.core.db.ODatabaseDocumentInternal in project orientdb by orientechnologies.

the class OCommandExecutorFunction method executeInContext.

public Object executeInContext(final OCommandContext iContext, final Map<Object, Object> iArgs) {
    parserText = request.getText();
    ODatabaseDocumentInternal db = ODatabaseRecordThreadLocal.INSTANCE.get();
    final OFunction f = db.getMetadata().getFunctionLibrary().getFunction(parserText);
    db.checkSecurity(ORule.ResourceGeneric.FUNCTION, ORole.PERMISSION_READ, f.getName());
    final OScriptManager scriptManager = Orient.instance().getScriptManager();
    final OPartitionedObjectPool.PoolEntry<ScriptEngine> entry = scriptManager.acquireDatabaseEngine(db.getName(), f.getLanguage());
    final ScriptEngine scriptEngine = entry.object;
    try {
        final Bindings binding = scriptManager.bind(scriptEngine.getBindings(ScriptContext.ENGINE_SCOPE), (ODatabaseDocumentTx) db, iContext, iArgs);
        try {
            final Object result;
            if (scriptEngine instanceof Invocable) {
                // INVOKE AS FUNCTION. PARAMS ARE PASSED BY POSITION
                final Invocable invocableEngine = (Invocable) scriptEngine;
                Object[] args = null;
                if (iArgs != null) {
                    args = new Object[iArgs.size()];
                    int i = 0;
                    for (Entry<Object, Object> arg : iArgs.entrySet()) args[i++] = arg.getValue();
                } else {
                    args = OCommonConst.EMPTY_OBJECT_ARRAY;
                }
                result = invocableEngine.invokeFunction(parserText, args);
            } else {
                // INVOKE THE CODE SNIPPET
                final Object[] args = iArgs == null ? null : iArgs.values().toArray();
                result = scriptEngine.eval(scriptManager.getFunctionInvoke(f, args), binding);
            }
            return OCommandExecutorUtility.transformResult(result);
        } catch (ScriptException e) {
            throw OException.wrapException(new OCommandScriptException("Error on execution of the script", request.getText(), e.getColumnNumber()), e);
        } catch (NoSuchMethodException e) {
            throw OException.wrapException(new OCommandScriptException("Error on execution of the script", request.getText(), 0), e);
        } catch (OCommandScriptException e) {
            // PASS THROUGH
            throw e;
        } finally {
            scriptManager.unbind(binding, iContext, iArgs);
        }
    } finally {
        scriptManager.releaseDatabaseEngine(f.getLanguage(), db.getName(), entry);
    }
}