_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q163700 | NotificationDto.transformToDto | train | public static List<NotificationDto> transformToDto(List<Notification> notifications) {
if (notifications == null) {
throw new WebApplicationException("Null entity object cannot be converted to Dto object.", Status.INTERNAL_SERVER_ERROR);
}
List<NotificationDto> result = new ArrayList<NotificationDto>();
for (Notification notification : notifications) {
result.add(transformToDto(notification));
}
return result;
} | java | {
"resource": ""
} |
q163701 | SignatureUtil.isSignatureValid | train | public static boolean isSignatureValid(String payload, String signature, String appSecret) {
try {
final Mac mac = Mac.getInstance(HMAC_SHA1);
mac.init(new SecretKeySpec(appSecret.getBytes(), HMAC_SHA1));
final byte[] rawHmac = mac.doFinal(payload.getBytes());
final String expected = signature.substring(5);
final String actual = bytesToHexString(rawHmac);
return expected.equals(actual);
} catch (NoSuchAlgorithmException | InvalidKeyException e) {
throw new RuntimeException(e);
}
} | java | {
"resource": ""
} |
q163702 | ProxyDataSourceBuilder.autoRetrieveGeneratedKeys | train | public ProxyDataSourceBuilder autoRetrieveGeneratedKeys(boolean autoClose, ResultSetProxyLogicFactory factory) {
this.autoRetrieveGeneratedKeys = true;
this.autoCloseGeneratedKeys = autoClose;
this.generatedKeysProxyLogicFactory = factory;
return this;
} | java | {
"resource": ""
} |
q163703 | AbstractQueryLogEntryCreator.getParametersToDisplay | train | protected SortedMap<String, String> getParametersToDisplay(List<ParameterSetOperation> params) {
// populate param map with sorted by key: key=index/name, value=first value
SortedMap<String, String> paramMap = new TreeMap<String, String>(new StringAsIntegerComparator());
for (ParameterSetOperation param : params) {
String key = getParameterKeyToDisplay(param);
String value = getParameterValueToDisplay(param);
paramMap.put(key, value);
}
return paramMap;
} | java | {
"resource": ""
} |
q163704 | QueryUtils.getQueryType | train | public static QueryType getQueryType(String query) {
final String trimmedQuery = removeCommentAndWhiteSpace(query);
if (trimmedQuery == null || trimmedQuery.length() < 1) {
return QueryType.OTHER;
}
final char firstChar = trimmedQuery.charAt(0);
final QueryType type;
switch (firstChar) {
case 'S':
case 's':
type = QueryType.SELECT;
break;
case 'I':
case 'i':
type = QueryType.INSERT;
break;
case 'U':
case 'u':
type = QueryType.UPDATE;
break;
case 'D':
case 'd':
type = QueryType.DELETE;
break;
default:
type = QueryType.OTHER;
}
return type;
} | java | {
"resource": ""
} |
q163705 | DefaultQueryLogEntryCreator.writeConnectionIdEntry | train | protected void writeConnectionIdEntry(StringBuilder sb, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
sb.append("Connection:");
sb.append(execInfo.getConnectionId());
sb.append(", ");
} | java | {
"resource": ""
} |
q163706 | DefaultQueryLogEntryCreator.writeTimeEntry | train | protected void writeTimeEntry(StringBuilder sb, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
sb.append("Time:");
sb.append(execInfo.getElapsedTime());
sb.append(", ");
} | java | {
"resource": ""
} |
q163707 | DefaultQueryLogEntryCreator.writeResultEntry | train | protected void writeResultEntry(StringBuilder sb, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
sb.append("Success:");
sb.append(execInfo.isSuccess() ? "True" : "False");
sb.append(", ");
} | java | {
"resource": ""
} |
q163708 | DefaultQueryLogEntryCreator.writeTypeEntry | train | protected void writeTypeEntry(StringBuilder sb, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
sb.append("Type:");
sb.append(getStatementType(execInfo.getStatementType()));
sb.append(", ");
} | java | {
"resource": ""
} |
q163709 | DefaultQueryLogEntryCreator.writeParamsEntry | train | protected void writeParamsEntry(StringBuilder sb, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
boolean isPrepared = execInfo.getStatementType() == StatementType.PREPARED;
sb.append("Params:[");
for (QueryInfo queryInfo : queryInfoList) {
for (List<ParameterSetOperation> parameters : queryInfo.getParametersList()) {
SortedMap<String, String> paramMap = getParametersToDisplay(parameters);
// parameters per batch.
// for prepared: (val1,val2,...)
// for callable: (key1=val1,key2=val2,...)
if (isPrepared) {
writeParamsForSinglePreparedEntry(sb, paramMap, execInfo, queryInfoList);
} else {
writeParamsForSingleCallableEntry(sb, paramMap, execInfo, queryInfoList);
}
}
}
chompIfEndWith(sb, ',');
sb.append("]");
} | java | {
"resource": ""
} |
q163710 | DefaultQueryLogEntryCreator.writeParamsForSinglePreparedEntry | train | protected void writeParamsForSinglePreparedEntry(StringBuilder sb, SortedMap<String, String> paramMap, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
sb.append("(");
for (Map.Entry<String, String> paramEntry : paramMap.entrySet()) {
sb.append(paramEntry.getValue());
sb.append(",");
}
chompIfEndWith(sb, ',');
sb.append("),");
} | java | {
"resource": ""
} |
q163711 | TracingMethodListener.getArguments | train | protected String getArguments(Object[] args) {
if (args == null || args.length == 0) {
return "";
}
StringBuilder sb = new StringBuilder();
if (args.length == 1) {
Object arg = args[0];
String param = getSingleArgParameterAsString(arg);
String displayParam = getSingleArgDisplayParameter(param);
if (arg instanceof String) {
sb.append("\"");
sb.append(displayParam);
sb.append("\"");
} else {
sb.append(displayParam);
}
} else {
for (int i = 0; i < args.length; i++) {
Object arg = args[i];
boolean lastArg = i == args.length - 1;
String param = getParameterAsString(arg);
String displayParam = getDisplayParameter(param);
if (arg instanceof String) {
sb.append("\"");
sb.append(displayParam);
sb.append("\"");
} else {
sb.append(displayParam);
}
if (!lastArg) {
sb.append(",");
}
}
}
return sb.toString();
} | java | {
"resource": ""
} |
q163712 | TracingMethodListener.getDisplayParameter | train | protected String getDisplayParameter(String parameter) {
if (parameter.length() <= this.parameterDisplayLength) {
return parameter;
}
return parameter.substring(0, this.parameterDisplayLength - 3) + "...";
} | java | {
"resource": ""
} |
q163713 | TracingMethodListener.constructMessage | train | protected String constructMessage(long seq, Throwable thrown, long execTime,
String connectionId, Class<?> targetClass, Method method, String args) {
StringBuilder sb = new StringBuilder();
sb.append("[");
sb.append(seq);
sb.append("]");
sb.append("[");
sb.append(thrown == null ? "success" : "fail");
sb.append("]");
sb.append("[");
sb.append(execTime);
sb.append("ms]");
sb.append("[conn=");
sb.append(connectionId);
sb.append("]");
if (thrown != null) {
sb.append("[error=");
sb.append(thrown.getMessage());
sb.append("]");
}
sb.append(" ");
sb.append(targetClass.getSimpleName());
sb.append("#");
sb.append(method.getName());
sb.append("(");
sb.append(args);
sb.append(")");
return sb.toString();
} | java | {
"resource": ""
} |
q163714 | ParameterReplacer.setRowId | train | public void setRowId(String parameterName, RowId x) {
recordByName(parameterName, getDeclaredMethod(CallableStatement.class, "setRowId", String.class, RowId.class), parameterName, x);
} | java | {
"resource": ""
} |
q163715 | DefaultJsonQueryLogEntryCreator.writeDataSourceNameEntry | train | protected void writeDataSourceNameEntry(StringBuilder sb, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
String name = execInfo.getDataSourceName();
sb.append("\"name\":\"");
sb.append(name == null ? "" : escapeSpecialCharacter(name));
sb.append("\", ");
} | java | {
"resource": ""
} |
q163716 | DefaultJsonQueryLogEntryCreator.writeBatchEntry | train | protected void writeBatchEntry(StringBuilder sb, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
sb.append("\"batch\":");
sb.append(execInfo.isBatch() ? "true" : "false");
sb.append(", ");
} | java | {
"resource": ""
} |
q163717 | DefaultJsonQueryLogEntryCreator.writeQuerySizeEntry | train | protected void writeQuerySizeEntry(StringBuilder sb, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
sb.append("\"querySize\":");
sb.append(queryInfoList.size());
sb.append(", ");
} | java | {
"resource": ""
} |
q163718 | DefaultJsonQueryLogEntryCreator.writeBatchSizeEntry | train | protected void writeBatchSizeEntry(StringBuilder sb, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
sb.append("\"batchSize\":");
sb.append(execInfo.getBatchSize());
sb.append(", ");
} | java | {
"resource": ""
} |
q163719 | DefaultJsonQueryLogEntryCreator.writeQueriesEntry | train | protected void writeQueriesEntry(StringBuilder sb, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
sb.append("\"query\":[");
for (QueryInfo queryInfo : queryInfoList) {
sb.append("\"");
sb.append(escapeSpecialCharacter(queryInfo.getQuery()));
sb.append("\",");
}
chompIfEndWith(sb, ',');
sb.append("], ");
} | java | {
"resource": ""
} |
q163720 | DefaultJsonQueryLogEntryCreator.writeParamsForSinglePreparedEntry | train | protected void writeParamsForSinglePreparedEntry(StringBuilder sb, SortedMap<String, String> paramMap, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
sb.append("[");
for (Map.Entry<String, String> paramEntry : paramMap.entrySet()) {
Object value = paramEntry.getValue();
if (value == null) {
sb.append("null");
} else {
sb.append("\"");
sb.append(escapeSpecialCharacter(value.toString()));
sb.append("\"");
}
sb.append(",");
}
chompIfEndWith(sb, ',');
sb.append("],");
} | java | {
"resource": ""
} |
q163721 | ESFilterBuilder.populateFilterBuilder | train | public QueryBuilder populateFilterBuilder(Expression condtionalExp, EntityMetadata m)
{
log.info("Populating filter for expression: " + condtionalExp);
QueryBuilder filter = null;
if (condtionalExp instanceof SubExpression)
{
filter = populateFilterBuilder(((SubExpression) condtionalExp).getExpression(), m);
}
else if (condtionalExp instanceof ComparisonExpression)
{
filter = getFilter(populateFilterClause((ComparisonExpression) condtionalExp), m);
}
else if (condtionalExp instanceof BetweenExpression)
{
filter = populateBetweenFilter((BetweenExpression) condtionalExp, m);
}
else if (condtionalExp instanceof LogicalExpression)
{
filter = populateLogicalFilterBuilder(condtionalExp, m);
}
else if (condtionalExp instanceof LikeExpression)
{
filter = populateLikeQuery((LikeExpression) condtionalExp, m);
}
else if (condtionalExp instanceof InExpression)
{
filter = populateInQuery((InExpression) condtionalExp, m);
}
else
{
log.error(condtionalExp.toParsedText() + "found in where clause. Not supported in elasticsearch.");
throw new KunderaException(condtionalExp.toParsedText() + " not supported in ElasticSearch");
}
log.debug("Following is the populated filter for required query: " + filter);
return filter;
} | java | {
"resource": ""
} |
q163722 | ESFilterBuilder.populateLikeQuery | train | private QueryBuilder populateLikeQuery(LikeExpression likeExpression, EntityMetadata metadata)
{
Expression patternValue = likeExpression.getPatternValue();
String field = likeExpression.getStringExpression().toString();
String likePattern = (patternValue instanceof InputParameter) ? kunderaQuery.getParametersMap()
.get((patternValue).toParsedText()).toString() : patternValue.toParsedText().toString();
String jpaField = getField(field);
log.debug("Pattern value for field " + field + " is: " + patternValue);
QueryBuilder filterBuilder = getQueryBuilder(kunderaQuery.new FilterClause(jpaField, Expression.LIKE,
likePattern, field), metadata);
return filterBuilder;
} | java | {
"resource": ""
} |
q163723 | ESFilterBuilder.populateInQuery | train | private QueryBuilder populateInQuery(InExpression inExpression, EntityMetadata metadata)
{
String property = getField(inExpression.getExpression().toParsedText());
Expression inItemsParameter = inExpression.getInItems();
log.debug("IN query parameters for field " + property + " is: " + inItemsParameter);
Iterable inItemsIterable = getInValuesCollection(inItemsParameter);
return getFilter(kunderaQuery.new FilterClause(property, Expression.IN, inItemsIterable, property), metadata);
} | java | {
"resource": ""
} |
q163724 | ESFilterBuilder.getInValuesCollection | train | private Collection getInValuesCollection(Expression inClauseValues)
{
Collection inParameterCollection = new ArrayList<>();
if (inClauseValues instanceof NullExpression)
{
log.debug("No items passed in IN clause values, returning blank IN values list");
return inParameterCollection;
}
if (inClauseValues instanceof InputParameter)
{
Object inValues = kunderaQuery.getParametersMap().get(inClauseValues.toParsedText());
log.debug(inClauseValues.toParsedText() + "named parameter found in query, Replacing parameter with "
+ inValues);
inParameterCollection = inValues.getClass().isArray() ? Arrays.asList((Object[]) inValues)
: (Collection) kunderaQuery.getParametersMap().get(inClauseValues.toParsedText());
return inParameterCollection;
}
if (inClauseValues instanceof CollectionExpression)
{
Iterator inValueIterator = ((CollectionExpression) inClauseValues).children().iterator();
log.debug("Collection object found for IN clause values");
while (inValueIterator.hasNext())
{
Expression value = (Expression) inValueIterator.next();
inParameterCollection.add(value.toParsedText());
}
return inParameterCollection;
}
throw new KunderaException(inClauseValues.toParsedText() + " not supported for IN clause");
} | java | {
"resource": ""
} |
q163725 | ESFilterBuilder.populateBetweenFilter | train | private QueryBuilder populateBetweenFilter(BetweenExpression betweenExpression, EntityMetadata m)
{
String lowerBoundExpression = getBetweenBoundaryValues(betweenExpression.getLowerBoundExpression());
String upperBoundExpression = getBetweenBoundaryValues(betweenExpression.getUpperBoundExpression());
String field = getField(betweenExpression.getExpression().toParsedText());
log.debug("Between clause for field " + field + "with lower bound " + lowerBoundExpression + "and upper bound "
+ upperBoundExpression);
return new AndQueryBuilder(getFilter(kunderaQuery.new FilterClause(field, Expression.GREATER_THAN_OR_EQUAL,
lowerBoundExpression, field), m), getFilter(kunderaQuery.new FilterClause(field,
Expression.LOWER_THAN_OR_EQUAL, upperBoundExpression,field), m));
} | java | {
"resource": ""
} |
q163726 | ESFilterBuilder.getBetweenBoundaryValues | train | private String getBetweenBoundaryValues(Expression boundExpression)
{
if (boundExpression instanceof IdentificationVariable || boundExpression instanceof NumericLiteral
|| boundExpression instanceof InputParameter)
{
Object value = (boundExpression instanceof InputParameter) ? kunderaQuery.getParametersMap().get(
(boundExpression).toParsedText()) : boundExpression.toParsedText();
return value.toString();
}
else if (boundExpression instanceof AdditionExpression)
{
String leftValue = checkInputParameter(((AdditionExpression) boundExpression).getLeftExpression());
String rightValue = checkInputParameter(((AdditionExpression) boundExpression).getRightExpression());
return new Integer(Integer.parseInt(leftValue) + Integer.parseInt(rightValue)).toString();
}
else if (boundExpression instanceof SubtractionExpression)
{
String leftValue = checkInputParameter(((SubtractionExpression) boundExpression).getLeftExpression());
String rightValue = checkInputParameter(((SubtractionExpression) boundExpression).getRightExpression());
return new Integer(Integer.parseInt(leftValue) - Integer.parseInt(rightValue)).toString();
}
else if (boundExpression instanceof MultiplicationExpression)
{
String leftValue = checkInputParameter(((MultiplicationExpression) boundExpression).getLeftExpression());
String rightValue = checkInputParameter(((MultiplicationExpression) boundExpression).getRightExpression());
return new Integer(Integer.parseInt(leftValue) * Integer.parseInt(rightValue)).toString();
}
else if (boundExpression instanceof DivisionExpression)
{
String leftValue = checkInputParameter(((DivisionExpression) boundExpression).getLeftExpression());
String rightValue = checkInputParameter(((DivisionExpression) boundExpression).getRightExpression());
return new Integer(Integer.parseInt(leftValue) / Integer.parseInt(rightValue)).toString();
}
return null;
} | java | {
"resource": ""
} |
q163727 | ESFilterBuilder.checkInputParameter | train | private String checkInputParameter(Expression expression)
{
return (expression instanceof InputParameter) ? kunderaQuery.getParametersMap()
.get((expression).toParsedText()).toString() : expression.toParsedText().toString();
} | java | {
"resource": ""
} |
q163728 | ESFilterBuilder.populateLogicalFilterBuilder | train | private QueryBuilder populateLogicalFilterBuilder(Expression logicalExp, EntityMetadata m)
{
String identifier = ((LogicalExpression) logicalExp).getIdentifier();
return (identifier.equalsIgnoreCase(LogicalExpression.AND)) ? getAndFilterBuilder(logicalExp, m) : (identifier
.equalsIgnoreCase(LogicalExpression.OR)) ? getOrFilterBuilder(logicalExp, m) : null;
} | java | {
"resource": ""
} |
q163729 | ESFilterBuilder.getAndFilterBuilder | train | private AndQueryBuilder getAndFilterBuilder(Expression logicalExp, EntityMetadata m)
{
AndExpression andExp = (AndExpression) logicalExp;
Expression leftExpression = andExp.getLeftExpression();
Expression rightExpression = andExp.getRightExpression();
return new AndQueryBuilder(populateFilterBuilder(leftExpression, m), populateFilterBuilder(rightExpression, m));
} | java | {
"resource": ""
} |
q163730 | ESFilterBuilder.getOrFilterBuilder | train | private OrQueryBuilder getOrFilterBuilder(Expression logicalExp, EntityMetadata m)
{
OrExpression orExp = (OrExpression) logicalExp;
Expression leftExpression = orExp.getLeftExpression();
Expression rightExpression = orExp.getRightExpression();
return new OrQueryBuilder(populateFilterBuilder(leftExpression, m), populateFilterBuilder(rightExpression, m));
} | java | {
"resource": ""
} |
q163731 | ESFilterBuilder.populateFilterClause | train | private FilterClause populateFilterClause(ComparisonExpression conditionalExpression)
{
String property = ((StateFieldPathExpression) conditionalExpression.getLeftExpression()).getPath(1);
String condition = conditionalExpression.getComparisonOperator();
Expression rightExpression = conditionalExpression.getRightExpression();
Object value = (rightExpression instanceof InputParameter) ? kunderaQuery.getParametersMap().get(
(rightExpression).toParsedText()) : rightExpression.toParsedText();
return (condition != null && property != null) ? kunderaQuery.new FilterClause(property, condition, value, property)
: null;
} | java | {
"resource": ""
} |
q163732 | EntityValidatorImpl.validate | train | @Override
// TODO: reduce Cyclomatic complexity
public final void validate(final Class<?> clazz)
{
if (classes.contains(clazz))
{
return;
}
if (log.isDebugEnabled())
log.debug("Validating " + clazz.getName());
// Is Entity?
// if (clazz.isAnnotationPresent(MappedSuperclass.class))
// {
// throw new InvalidEntityDefinitionException("JPA operation over MappedSuperclass are not allowed" + clazz);
// }
// Is Entity?
if (!clazz.isAnnotationPresent(Entity.class))
{
throw new InvalidEntityDefinitionException(clazz.getName() + " is not annotated with @Entity.");
}
// TODO:: add validation for MappedSuperClass.
// // Must be annotated with @Table
// if (!clazz.isAnnotationPresent(Table.class))
// {
// throw new InvalidEntityDefinitionException(clazz.getName() + " must be annotated with @Table.");
// }
// must have a default no-argument constructor
try
{
clazz.getConstructor();
}
catch (NoSuchMethodException nsme)
{
throw new InvalidEntityDefinitionException(clazz.getName()
+ " must have a default no-argument constructor.");
}
// Check for @Key and ensure that there is just 1 @Key field of String
// type.
List<Field> keys = new ArrayList<Field>();
for (Field field : clazz.getDeclaredFields())
{
if (field.isAnnotationPresent(Id.class) && field.isAnnotationPresent(EmbeddedId.class))
{
throw new InvalidEntityDefinitionException(clazz.getName()
+ " must have either @Id field or @EmbeddedId field");
}
if (field.isAnnotationPresent(Id.class))
{
keys.add(field);
// validate @GeneratedValue annotation if given
if (field.isAnnotationPresent(GeneratedValue.class))
{
validateGeneratedValueAnnotation(clazz, field);
}
}
else if (field.isAnnotationPresent(EmbeddedId.class))
{
keys.add(field);
}
}
if (keys.size() < 0)
{
throw new InvalidEntityDefinitionException(clazz.getName() + " must have an @Id field.");
}
else if (keys.size() > 1)
{
throw new InvalidEntityDefinitionException(clazz.getName() + " can only have 1 @Id field.");
}
// save in cache
classes.add(clazz);
} | java | {
"resource": ""
} |
q163733 | ClasspathReader.findResourcesInUrls | train | private URL[] findResourcesInUrls(String classRelativePath, URL[] urls)
{
List<URL> list = new ArrayList<URL>();
for (URL url : urls)
{
if (AllowedProtocol.isValidProtocol(url.getProtocol().toUpperCase()) && url.getPath().endsWith(".jar"))
{
try
{
JarFile jarFile = new JarFile(URLDecoder.decode(url.getFile(), Constants.CHARSET_UTF8));
// Checking the dependencies of this jar file
Manifest manifest = jarFile.getManifest();
if (manifest != null)
{
String classPath = manifest.getMainAttributes().getValue("Class-Path");
// Scan all entries in the classpath if they are
// specified in the jar
if (!StringUtils.isEmpty(classPath))
{
List<URL> subList = new ArrayList<URL>();
for (String cpEntry : classPath.split(" "))
{
try
{
subList.add(new URL(cpEntry));
}
catch (MalformedURLException e)
{
URL subResources = ClasspathReader.class.getClassLoader().getResource(cpEntry);
if (subResources != null)
{
subList.add(subResources);
}
// logger.warn("Incorrect URL in the classpath of a jar file ["
// + url.toString()
// + "]: " + cpEntry);
}
}
list.addAll(Arrays.asList(findResourcesInUrls(classRelativePath,
subList.toArray(new URL[subList.size()]))));
}
}
JarEntry present = jarFile.getJarEntry(classRelativePath + ".class");
if (present != null)
{
list.add(url);
}
}
catch (IOException e)
{
logger.warn("Error during loading from context , Caused by:" + e.getMessage());
}
}
else if (url.getPath().endsWith("/"))
{
File file = new File(url.getPath() + classRelativePath + ".class");
if (file.exists())
{
try
{
list.add(file.toURL());
}
catch (MalformedURLException e)
{
throw new ResourceReadingException(e);
}
}
}
}
return list.toArray(new URL[list.size()]);
} | java | {
"resource": ""
} |
q163734 | ClasspathReader.findResourcesByContextLoader | train | private final URL[] findResourcesByContextLoader()
{
List<URL> list = new ArrayList<URL>();
ClassLoader classLoader = this.getClass().getClassLoader();
assert classLoader != null;
URL[] urls = ((URLClassLoader) classLoader).getURLs();
for (String fullyQualifiedClassName : classesToScan)
{
String classRelativePath = fullyQualifiedClassName.replace(".", "/");
list.addAll(Arrays.asList(findResourcesInUrls(classRelativePath, urls)));
}
return list.toArray(new URL[list.size()]);
} | java | {
"resource": ""
} |
q163735 | StreamUtils.toInputStream | train | public static InputStream toInputStream(String s)
{
InputStream is = new ByteArrayInputStream(s.getBytes());
return is;
} | java | {
"resource": ""
} |
q163736 | MongoDBClientFactory.onSetMongoServerProperties | train | private MongoClient onSetMongoServerProperties(String contactNode, String defaultPort, String poolSize,
List<ServerAddress> addrs, List<MongoCredential> credentials)
{
MongoClientOptions mo;
MongoDBSchemaMetadata metadata = MongoDBPropertyReader.msmd;
ClientProperties cp = metadata != null ? metadata.getClientProperties() : null;
Properties propsFromCp = null;
if (cp != null)
{
DataStore dataStore = metadata != null ? metadata.getDataStore() : null;
List<Server> servers = dataStore != null && dataStore.getConnection() != null ? dataStore.getConnection()
.getServers() : null;
if (servers != null && !servers.isEmpty())
{
for (Server server : servers)
{
addrs.add(new ServerAddress(server.getHost().trim(), Integer.parseInt(server.getPort().trim())));
}
}
propsFromCp = dataStore != null && dataStore.getConnection() != null ? dataStore.getConnection()
.getProperties() : null;
}
else
{
for (String node : contactNode.split(Constants.COMMA))
{
if (StringUtils.countMatches(node, Constants.COLON) == 1)
{
// node is given with hostname and port
// count == 1 is to exclude IPv6 addresses
String host = node.split(":")[0];
int port = Integer.parseInt(node.split(Constants.COLON)[1]);
addrs.add(new ServerAddress(host.trim(), port));
}
else
{
addrs.add(new ServerAddress(node.trim(), Integer.parseInt(defaultPort.trim())));
}
}
}
MongoClientOptions.Builder b = new PopulateMongoOptions(propsFromCp, externalProperties).prepareBuilder();
mo = b.build();
if (mo.getConnectionsPerHost() <= 0 && !StringUtils.isEmpty(poolSize))
{
mo = b.connectionsPerHost(Integer.parseInt(poolSize)).build();
}
return new MongoClient(addrs, credentials, mo);
} | java | {
"resource": ""
} |
q163737 | HostConfiguration.buildHosts | train | private void buildHosts(Map externalProperties, List<Server> servers, String persistenceUnit,
final KunderaMetadata kunderaMetadata)
{
persistenceUnitMetadata = kunderaMetadata.getApplicationMetadata().getPersistenceUnitMetadata(persistenceUnit);
Properties props = persistenceUnitMetadata.getProperties();
this.externalProperties = externalProperties;
String hosts = null;
String portAsString = null;
if (externalProperties != null)
{
hosts = (String) externalProperties.get(PersistenceProperties.KUNDERA_NODES);
portAsString = (String) externalProperties.get(PersistenceProperties.KUNDERA_PORT);
}
if (hosts == null)
{
hosts = (String) props.get(PersistenceProperties.KUNDERA_NODES);
}
if (portAsString == null)
{
portAsString = (String) props.get(PersistenceProperties.KUNDERA_PORT);
}
if (hosts != null && portAsString != null)
{
buildHosts(hosts, portAsString, this.hostsList);
}
else if (servers != null && servers.size() >= 1)
{
buildHosts(servers, this.hostsList);
}
} | java | {
"resource": ""
} |
q163738 | ResultIterator.onCheckRelation | train | private void onCheckRelation()
{
try
{
results = populateEntities(entityMetadata, client);
if (entityMetadata.isRelationViaJoinTable()
|| (entityMetadata.getRelationNames() != null && !(entityMetadata.getRelationNames().isEmpty())))
{
query.setRelationalEntities(results, client, entityMetadata);
}
}
catch (Exception e)
{
throw new PersistenceException("Error while scrolling over results, Caused by :.", e);
}
} | java | {
"resource": ""
} |
q163739 | ResultIterator.appendWhereClauseWithScroll | train | private String appendWhereClauseWithScroll(String parsedQuery)
{
String queryWithoutLimit = parsedQuery.replaceAll(
parsedQuery.substring(parsedQuery.lastIndexOf(CQLTranslator.LIMIT), parsedQuery.length()), "");
CQLTranslator translator = new CQLTranslator();
final String tokenCondition = prepareNext(translator, queryWithoutLimit);
StringBuilder builder = new StringBuilder(queryWithoutLimit);
if (tokenCondition != null)
{
if (query.getKunderaQuery().getFilterClauseQueue().isEmpty())
{
builder.append(CQLTranslator.ADD_WHERE_CLAUSE);
}
else
{
builder.append(CQLTranslator.AND_CLAUSE);
}
builder.append(tokenCondition);
}
String replaceQuery = replaceAndAppendLimit(builder.toString());
builder.replace(0, builder.toString().length(), replaceQuery);
translator.buildFilteringClause(builder);
// in case of fetch by ID, token condition will be null and results will
// not be empty.
return checkOnEmptyResult() && tokenCondition == null ? null : builder.toString();
} | java | {
"resource": ""
} |
q163740 | ResultIterator.replaceAndAppendLimit | train | private String replaceAndAppendLimit(String parsedQuery)
{
StringBuilder builder = new StringBuilder(parsedQuery);
onLimit(builder);
parsedQuery = builder.toString();
return parsedQuery;
} | java | {
"resource": ""
} |
q163741 | ResultIterator.onLimit | train | private void onLimit(StringBuilder builder)
{
builder.append(CQLTranslator.LIMIT);
builder.append(this.maxResult);
} | java | {
"resource": ""
} |
q163742 | ResultIterator.getConditionOnIdColumn | train | private Map<Boolean, String> getConditionOnIdColumn(String idColumn)
{
Map<Boolean, String> filterIdResult = new HashMap<Boolean, String>();
MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
entityMetadata.getPersistenceUnit());
EmbeddableType keyObj = null;
if (metaModel.isEmbeddable(entityMetadata.getIdAttribute().getBindableJavaType()))
{
keyObj = metaModel.embeddable(entityMetadata.getIdAttribute().getBindableJavaType());
}
for (Object o : query.getKunderaQuery().getFilterClauseQueue())
{
if (o instanceof FilterClause)
{
FilterClause clause = ((FilterClause) o);
String fieldName = clause.getProperty();
String condition = clause.getCondition();
if (keyObj != null && fieldName.equals(idColumn)
|| (keyObj != null && StringUtils.contains(fieldName, '.')) || (idColumn.equals(fieldName)))
{
filterIdResult.put(true, condition);
break;
}
}
}
return filterIdResult;
} | java | {
"resource": ""
} |
q163743 | ResultIterator.idValueInByteArr | train | private byte[] idValueInByteArr()
{
Object entity = results.get(results.size() - 1);
Object id = PropertyAccessorHelper.getId(entity, entityMetadata);
String idName = ((AbstractAttribute) entityMetadata.getIdAttribute()).getJPAColumnName();
Class idClazz = ((AbstractAttribute) entityMetadata.getIdAttribute()).getBindableJavaType();
MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
entityMetadata.getPersistenceUnit());
EmbeddableType keyObj = null;
ByteBuffer bytes = null;
// if the key attribute is composite
if (metaModel.isEmbeddable(entityMetadata.getIdAttribute().getBindableJavaType()))
{
keyObj = metaModel.embeddable(entityMetadata.getIdAttribute().getBindableJavaType());
Field embeddedField = getPartitionKeyField();
Attribute partitionKey = keyObj.getAttribute(embeddedField.getName());
Object partitionKeyValue = PropertyAccessorHelper.getObject(id, (Field) partitionKey.getJavaMember());
bytes = CassandraUtilities.toBytes(partitionKeyValue, (Field) partitionKey.getJavaMember());
}
else
{
bytes = query.getBytesValue(idName, entityMetadata, id);
}
return bytes.array();
} | java | {
"resource": ""
} |
q163744 | ResultIterator.getPartitionKeyField | train | private Field getPartitionKeyField()
{
Field[] embeddedFields = entityMetadata.getIdAttribute().getBindableJavaType().getDeclaredFields();
Field field = null;
for (Field embeddedField : embeddedFields)
{
if (!ReflectUtils.isTransientOrStatic(embeddedField))
{
field = embeddedField;
break;
}
}
return field;
} | java | {
"resource": ""
} |
q163745 | ResultIterator.getEntity | train | private E getEntity(Object entity)
{
return (E) (entity.getClass().isAssignableFrom(EnhanceEntity.class) ? ((EnhanceEntity) entity).getEntity()
: entity);
} | java | {
"resource": ""
} |
q163746 | ResultIterator.replaceAppliedToken | train | private String replaceAppliedToken(String query)
{
final String tokenRegex = "\\btoken\\(";
final String pattern = "#TOKENKUNDERA#"; // need to replace with this as
// pattern matcher was
// returning false.
query = query.replaceAll(tokenRegex, pattern);
if (query.indexOf(pattern) > -1) // Means token( has been present and
// replaced.
{
CQLTranslator translator = new CQLTranslator();
int closingIndex = query.indexOf(CQLTranslator.CLOSE_BRACKET, query.lastIndexOf(pattern));
String object = query.substring(query.lastIndexOf(pattern) + pattern.length(), closingIndex);
Object entity = results.get(results.size() - 1);
Class idClazz = ((AbstractAttribute) entityMetadata.getIdAttribute()).getBindableJavaType();
Object id = PropertyAccessorHelper.getId(entity, entityMetadata);
StringBuilder builder = new StringBuilder();
translator.appendValue(builder, idClazz, id, false, false);
query = query.replaceAll(pattern + object, pattern + builder.toString());
query = query.replaceAll(pattern, CQLTranslator.TOKEN);
}
return query;
} | java | {
"resource": ""
} |
q163747 | Node.getParentNode | train | @Override
public Node getParentNode(String parentNodeId)
{
NodeLink link = new NodeLink(parentNodeId, getNodeId());
if (this.parents == null)
{
return null;
}
else
{
return this.parents.get(link);
}
} | java | {
"resource": ""
} |
q163748 | Node.getChildNode | train | @Override
public Node getChildNode(String childNodeId)
{
NodeLink link = new NodeLink(getNodeId(), childNodeId);
if (this.children == null)
{
return null;
}
else
{
return this.children.get(link);
}
} | java | {
"resource": ""
} |
q163749 | MetamodelImpl.getEntityMetadataMap | train | public Map<String, EntityMetadata> getEntityMetadataMap()
{
if (entityMetadataMap == null)
{
entityMetadataMap = new HashMap<String, EntityMetadata>();
}
return entityMetadataMap;
} | java | {
"resource": ""
} |
q163750 | MetamodelImpl.getEntityNameToClassMap | train | public Map<String, Class<?>> getEntityNameToClassMap()
{
if (entityNameToClassMap == null)
{
entityNameToClassMap = new HashMap<String, Class<?>>();
}
return entityNameToClassMap;
} | java | {
"resource": ""
} |
q163751 | MetamodelImpl.assignManagedTypes | train | public void assignManagedTypes(Map<Class<?>, EntityType<?>> managedTypes)
{
if (this.entityTypes == null)
{
this.entityTypes = managedTypes;
}
else
{
this.entityTypes.putAll(managedTypes);
}
} | java | {
"resource": ""
} |
q163752 | MetamodelImpl.assignEmbeddables | train | public void assignEmbeddables(Map<Class<?>, ManagedType<?>> embeddables)
{
if (this.embeddables == null)
{
this.embeddables = embeddables;
}
else
{
this.embeddables.putAll(embeddables);
}
} | java | {
"resource": ""
} |
q163753 | MetamodelImpl.assignMappedSuperClass | train | public void assignMappedSuperClass(Map<Class<?>, ManagedType<?>> mappedSuperClass)
{
if (this.mappedSuperClassTypes == null)
{
this.mappedSuperClassTypes = mappedSuperClass;
}
else
{
this.mappedSuperClassTypes.putAll(mappedSuperClassTypes);
}
} | java | {
"resource": ""
} |
q163754 | MetamodelImpl.isEmbeddable | train | public boolean isEmbeddable(Class embeddableClazz)
{
return embeddables != null ? embeddables.containsKey(embeddableClazz)
&& embeddables.get(embeddableClazz).getPersistenceType().equals(PersistenceType.EMBEDDABLE) : false;
} | java | {
"resource": ""
} |
q163755 | MetamodelImpl.getEntityAttribute | train | public Attribute getEntityAttribute(Class clazz, String fieldName)
{
if (entityTypes != null && entityTypes.containsKey(clazz))
{
EntityType entityType = entityTypes.get(clazz);
return entityType.getAttribute(fieldName);
}
throw new IllegalArgumentException("No entity found: " + clazz);
} | java | {
"resource": ""
} |
q163756 | MetamodelImpl.getEmbeddables | train | public Map<String, EmbeddableType> getEmbeddables(Class clazz)
{
Map<String, EmbeddableType> embeddableAttibutes = new HashMap<String, EmbeddableType>();
if (entityTypes != null)
{
EntityType entity = entityTypes.get(clazz);
Iterator<Attribute> iter = entity.getAttributes().iterator();
while (iter.hasNext())
{
Attribute attribute = iter.next();
if (isEmbeddable(((AbstractAttribute) attribute).getBindableJavaType()))
{
embeddableAttibutes.put(attribute.getName(),
embeddable(((AbstractAttribute) attribute).getBindableJavaType()));
}
}
}
return embeddableAttibutes;
} | java | {
"resource": ""
} |
q163757 | IndexProcessor.prepareCompositeIndexName | train | private String prepareCompositeIndexName(String indexedColumns, final EntityType entityType, EntityMetadata metadata)
{
StringTokenizer tokenizer = new StringTokenizer(indexedColumns, ",");
StringBuilder builder = new StringBuilder();
while (tokenizer.hasMoreTokens())
{
String fieldName = (String) tokenizer.nextElement();
StringTokenizer stringTokenizer = new StringTokenizer(fieldName, ".");
// if need to select embedded columns
if (stringTokenizer.countTokens() > 1)
{
fieldName = stringTokenizer.nextToken();
String embeddedFieldName = stringTokenizer.nextToken();
Attribute embeddable = entityType.getAttribute(fieldName);
EmbeddableType embeddedEntity = (EmbeddableType) kunderaMetadata.getApplicationMetadata()
.getMetaModelBuilder(metadata.getPersistenceUnit()).getEmbeddables()
.get(((AbstractAttribute) embeddable).getBindableJavaType());
Attribute embeddedAttribute = embeddedEntity.getAttribute(embeddedFieldName);
builder.append(((AbstractAttribute) embeddedAttribute).getJPAColumnName());
}
else
{
builder.append(((AbstractAttribute) entityType.getAttribute(fieldName)).getJPAColumnName());
}
builder.append(",");
}
// scan embeddable as well for
builder.deleteCharAt(builder.length() - 1);
return builder.toString();
} | java | {
"resource": ""
} |
q163758 | KunderaPersistenceProviderUtil.isLoadedWithoutReference | train | @Override
public LoadState isLoadedWithoutReference(Object paramObject, String paramString)
{
return PersistenceUtilHelper.isLoadedWithoutReference(paramObject, paramString, provider.getCache());
} | java | {
"resource": ""
} |
q163759 | FloatAccessor.toInt | train | private int toInt(byte[] data)
{
if (data == null || data.length != 4)
return 0x0;
return (int) ( // NOTE: type cast not necessary for int
(0xff & data[0]) << 24 | (0xff & data[1]) << 16 | (0xff & data[2]) << 8 | (0xff & data[3]) << 0);
} | java | {
"resource": ""
} |
q163760 | DocumentDownloadBean.download | train | public void download()
{
DataKeeperService service = DataKeeperUtils.getService();
setDocumentId(Integer.parseInt(FacesUtils.getRequest().getParameter("documentId")));
DocumentInfo document = service.findDocumentByDocumentId(getDocumentId());
final HttpServletResponse response = (HttpServletResponse) FacesContext.getCurrentInstance()
.getExternalContext().getResponse();
ServletOutputStream out = null;
try
{
out = response.getOutputStream();
out.write(document.getData(), 0, 4096);
}
catch (IOException e)
{
}
finally
{
if (out != null)
{
try
{
out.flush();
out.close();
}
catch (IOException e)
{
}
}
}
FacesContext.getCurrentInstance().responseComplete();
} | java | {
"resource": ""
} |
q163761 | SparkClient.getDataFrame | train | public DataFrame getDataFrame(String query, EntityMetadata m, KunderaQuery kunderaQuery)
{
PersistenceUnitMetadata puMetadata = kunderaMetadata.getApplicationMetadata().getPersistenceUnitMetadata(
persistenceUnit);
String clientName = puMetadata.getProperty(DATA_CLIENT).toLowerCase();
SparkDataClient dataClient = SparkDataClientFactory.getDataClient(clientName);
if (registeredTables.get(m.getTableName()) == null || !registeredTables.get(m.getTableName()))
{
dataClient.registerTable(m, this);
registeredTables.put(m.getTableName(), true);
}
// at this level temp table or table should be ready
DataFrame dataFrame = sqlContext.sql(query);
return dataFrame;
} | java | {
"resource": ""
} |
q163762 | TableProcessor.onIdAttribute | train | private void onIdAttribute(final MetaModelBuilder builder, EntityMetadata entityMetadata, final Class clazz, Field f)
{
EntityType entity = (EntityType) builder.getManagedTypes().get(clazz);
Attribute attrib = entity.getAttribute(f.getName());
if (!attrib.isCollection() && ((SingularAttribute) attrib).isId())
{
entityMetadata.setIdAttribute((SingularAttribute) attrib);
populateIdAccessorMethods(entityMetadata, clazz, f);
}
} | java | {
"resource": ""
} |
q163763 | TableProcessor.onFamilyType | train | private void onFamilyType(EntityMetadata entityMetadata, final Class clazz, Field f)
{
if (entityMetadata.getType() == null || !entityMetadata.getType().equals(Type.SUPER_COLUMN_FAMILY))
{
if ((f.isAnnotationPresent(Embedded.class) && f.getType().getAnnotation(Embeddable.class) != null))
{
entityMetadata.setType(Type.SUPER_COLUMN_FAMILY);
}
else if (f.isAnnotationPresent(ElementCollection.class) && !MetadataUtils.isBasicElementCollectionField(f))
{
entityMetadata.setType(Type.SUPER_COLUMN_FAMILY);
}
else
{
entityMetadata.setType(Type.COLUMN_FAMILY);
}
}
} | java | {
"resource": ""
} |
q163764 | DataKeeperServiceImpl.encriptPassword | train | public String encriptPassword(String password)
{
String newpassword = null;
byte[] defaultBytes = password.getBytes();
try
{
MessageDigest algorithm = MessageDigest.getInstance("MD5");
algorithm.reset();
algorithm.update(defaultBytes);
byte messageDigest[] = algorithm.digest();
StringBuffer hexString = new StringBuffer();
for (int i = 0; i < messageDigest.length; i++)
{
hexString.append(Integer.toHexString(0xFF & messageDigest[i]));
}
newpassword = hexString.toString();
}
catch (NoSuchAlgorithmException e)
{
log.error("Error while encripting password {}, caused by : .", password, e);
throw new PersistenceException(e);
}
return newpassword;
} | java | {
"resource": ""
} |
q163765 | AbstractEntityReader.findById | train | protected EnhanceEntity findById(Object primaryKey, EntityMetadata m, Client client)
{
try
{
Object o = client.find(m.getEntityClazz(), primaryKey);
if (o == null)
{
// No entity found
return null;
}
else
{
return o instanceof EnhanceEntity ? (EnhanceEntity) o : new EnhanceEntity(o, getId(o, m), null);
}
}
catch (Exception e)
{
throw new EntityReaderException(e);
}
} | java | {
"resource": ""
} |
q163766 | AbstractEntityReader.onRelation | train | private void onRelation(final Object entity, final Map<String, Object> relationsMap, final EntityMetadata m,
final PersistenceDelegator pd, Relation relation, ForeignKey relationType, boolean lazilyloaded,
Map<Object, Object> relationStack)
{
FetchType fetchType = relation.getFetchType();
if (!lazilyloaded && fetchType.equals(FetchType.LAZY))
{
final Object entityId = PropertyAccessorHelper.getId(entity, m);
getAssociationBuilder().setProxyRelationObject(entity, relationsMap, m, pd, entityId, relation);
}
else
{
if (relation.getType().equals(ForeignKey.MANY_TO_MANY))
{
// First, Save this entity to persistence cache
Field f = relation.getProperty();
Object object = PropertyAccessorHelper.getObject(entity, f);
final Object entityId = PropertyAccessorHelper.getId(entity, m);
PersistenceCacheManager.addEntityToPersistenceCache(entity, pd, entityId);
getAssociationBuilder().populateRelationForM2M(entity, m, pd, relation, object, relationsMap);
}
else
{
onRelation(entity, relationsMap, relation, m, pd, lazilyloaded, relationStack);
}
}
} | java | {
"resource": ""
} |
q163767 | AbstractEntityReader.onRelation | train | private void onRelation(Object entity, Map<String, Object> relationsMap, final Relation relation,
final EntityMetadata metadata, final PersistenceDelegator pd, boolean lazilyloaded,
Map<Object, Object> relationStack)
{
final Object entityId = PropertyAccessorHelper.getId(entity, metadata);
// if relation map contains value, then invoke target entity with find
// by id.
// else invoke target entity for find by relation, pass it's entityId as
// a column value and relation.getJoinColumnName as column name.
Object relationValue = relationsMap != null ? relationsMap.get(relation.getJoinColumnName(kunderaMetadata))
: null;
EntityMetadata targetEntityMetadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata,
relation.getTargetEntity());
List relationalEntities = fetchRelations(relation, metadata, pd, entityId, relationValue, targetEntityMetadata);
if (relationalEntities != null)
{
for (Object relationEntity : relationalEntities)
{
if (relationEntity != null)
{
addToRelationStack(relationStack, relationEntity, targetEntityMetadata);
}
}
for (Object relationEntity : relationalEntities)
{
if (relationEntity != null)
{
onParseRelation(entity, pd, targetEntityMetadata, relationEntity, relation, lazilyloaded,
relationStack);
PersistenceCacheManager.addEntityToPersistenceCache(getEntity(relationEntity), pd,
PropertyAccessorHelper.getId(relationEntity, targetEntityMetadata));
}
}
}
} | java | {
"resource": ""
} |
q163768 | AbstractEntityReader.onParseRelation | train | private void onParseRelation(Object entity, final PersistenceDelegator pd, EntityMetadata targetEntityMetadata,
Object relationEntity, Relation relation, boolean lazilyloaded, Map<Object, Object> relationStack)
{
parseRelations(entity, getEntity(relationEntity), getPersistedRelations(relationEntity), pd,
targetEntityMetadata, lazilyloaded, relationStack);
// if relation ship is unary, no problem else we need to add
setRelationToEntity(entity, relationEntity, relation);
} | java | {
"resource": ""
} |
q163769 | AbstractEntityReader.setRelationToEntity | train | private void setRelationToEntity(Object entity, Object relationEntity, Relation relation)
{
if (relation.getTargetEntity().isAssignableFrom(getEntity(relationEntity).getClass()))
{
if (relation.isUnary())
{
PropertyAccessorHelper.set(entity, relation.getProperty(), getEntity(relationEntity));
}
else
{
Object associationObject = PropertyAccessorHelper.getObject(entity, relation.getProperty());
if (associationObject == null || ProxyHelper.isProxyOrCollection(associationObject))
{
associationObject = PropertyAccessorHelper.getCollectionInstance(relation.getProperty());
PropertyAccessorHelper.set(entity, relation.getProperty(), associationObject);
}
((Collection) associationObject).add(getEntity(relationEntity));
}
}
} | java | {
"resource": ""
} |
q163770 | AbstractEntityReader.parseRelations | train | private void parseRelations(final Object originalEntity, final Object relationEntity,
final Map<String, Object> relationsMap, final PersistenceDelegator pd, final EntityMetadata metadata,
boolean lazilyloaded, Map<Object, Object> relationStack)
{
for (Relation relation : metadata.getRelations())
{
if (relation != null)
{
FetchType fetchType = relation.getFetchType();
if (!lazilyloaded && fetchType.equals(FetchType.LAZY))
{
final Object entityId = PropertyAccessorHelper.getId(relationEntity, metadata);
getAssociationBuilder().setProxyRelationObject(relationEntity, relationsMap, metadata, pd,
entityId, relation);
}
else
{
if (relation.isUnary() && relation.getTargetEntity().isAssignableFrom(originalEntity.getClass()))
{
Object associationObject = PropertyAccessorHelper.getObject(relationEntity,
relation.getProperty());
if (relation.getType().equals(ForeignKey.ONE_TO_ONE))
{
if ((associationObject == null || ProxyHelper.isProxyOrCollection(associationObject)))
{
PropertyAccessorHelper.set(relationEntity, relation.getProperty(), originalEntity);
}
}
else if (relationsMap != null
&& relationsMap.containsKey(relation.getJoinColumnName(kunderaMetadata)))
{
PropertyAccessorHelper.set(relationEntity, relation.getProperty(), originalEntity);
}
}
else
{
// Here
// onRelation(relationEntity, relationsMap, metadata,
// pd,
// relation, relationType);
final Object entityId = PropertyAccessorHelper.getId(relationEntity, metadata);
Object relationValue = relationsMap != null ? relationsMap.get(relation
.getJoinColumnName(kunderaMetadata)) : null;
final EntityMetadata targetEntityMetadata = KunderaMetadataManager.getEntityMetadata(
kunderaMetadata, relation.getTargetEntity());
List immediateRelations = fetchRelations(relation, metadata, pd, entityId, relationValue,
targetEntityMetadata);
// Here in case of one-to-many/many-to-one we should
// skip
// this
// relation as it
if (immediateRelations != null && !immediateRelations.isEmpty())
{
for (Object immediateRelation : immediateRelations)
{
if (immediateRelation != null )
{
if (existsInRelationStack(relationStack, immediateRelation, targetEntityMetadata))
{
setRelationToEntity(
relationEntity,
fetchFromRelationStack(relationStack, immediateRelation,
targetEntityMetadata), relation);
}
else
{
addToRelationStack(relationStack, immediateRelation, targetEntityMetadata);
onParseRelation(relationEntity, pd, targetEntityMetadata, immediateRelation,
relation, lazilyloaded, relationStack);
}
PersistenceCacheManager.addEntityToPersistenceCache(getEntity(relationEntity), pd,
PropertyAccessorHelper.getId(relationEntity, metadata));
}
}
}
}
}
}
}
} | java | {
"resource": ""
} |
q163771 | AbstractEntityReader.getPersistedRelations | train | private Map<String, Object> getPersistedRelations(Object relationEntity)
{
return relationEntity != null && relationEntity.getClass().isAssignableFrom(EnhanceEntity.class) ? ((EnhanceEntity) relationEntity)
.getRelations() : null;
} | java | {
"resource": ""
} |
q163772 | AbstractEntityReader.getEntity | train | private Object getEntity(Object relationEntity)
{
return relationEntity != null && relationEntity.getClass().isAssignableFrom(EnhanceEntity.class) ? ((EnhanceEntity) relationEntity)
.getEntity() : relationEntity;
} | java | {
"resource": ""
} |
q163773 | AbstractEntityReader.onAssociationUsingLucene | train | protected List<EnhanceEntity> onAssociationUsingLucene(EntityMetadata m, Client client, List<EnhanceEntity> ls)
{
Set<String> rSet = fetchDataFromLucene(m.getEntityClazz(), client);
List resultList = client.findAll(m.getEntityClazz(), null, rSet.toArray(new String[] {}));
return m.getRelationNames() != null && !m.getRelationNames().isEmpty() ? resultList : transform(m, ls,
resultList);
} | java | {
"resource": ""
} |
q163774 | AbstractEntityReader.fetchDataFromLucene | train | protected Set<String> fetchDataFromLucene(Class<?> clazz, Client client)
{
// use lucene to query and get Pk's only.
// go to client and get relation with values.!
// populate EnhanceEntity
/** The lucene query from jpa query. */
String luceneQueryFromJPAQuery = KunderaCoreUtils.getLuceneQueryFromJPAQuery(kunderaQuery, kunderaMetadata);
Map<String, Object> results = client.getIndexManager().search(clazz, luceneQueryFromJPAQuery);
Set rSet = new HashSet(results.values());
return rSet;
} | java | {
"resource": ""
} |
q163775 | AbstractEntityReader.compareTo | train | private boolean compareTo(Object relationalEntity, Object originalEntity)
{
if (relationalEntity != null && originalEntity != null
&& relationalEntity.getClass().isAssignableFrom(originalEntity.getClass()))
{
EntityMetadata metadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata,
originalEntity.getClass());
Object relationalEntityId = PropertyAccessorHelper.getId(relationalEntity, metadata);
Object originalEntityId = PropertyAccessorHelper.getId(originalEntity, metadata);
return relationalEntityId.equals(originalEntityId);
}
return false;
} | java | {
"resource": ""
} |
q163776 | HBaseSchemaManager.createOrUpdateSchema | train | private void createOrUpdateSchema(Boolean isUpdate)
{
createNamespace(isUpdate);
readExternalProperties();
Map<Class<?>, EntityType<?>> entityMap = kunderaMetadata.getApplicationMetadata()
.getMetaModelBuilder(puMetadata.getPersistenceUnitName()).getManagedTypes();
// iterating all classes of pu to generate schema
for (Class<?> clazz : entityMap.keySet())
{
EntityMetadata m = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, clazz);
if (m != null)
{
String tablename = m.getTableName();
HTableDescriptor hTableDescriptor = getTableDescriptor(clazz, entityMap.get(clazz), tablename);
String hTableName = HBaseUtils.getHTableName(databaseName, tablename);
createOrUpdateTable(hTableName, hTableDescriptor);
}
}
} | java | {
"resource": ""
} |
q163777 | HBaseSchemaManager.getTableDescriptor | train | private HTableDescriptor getTableDescriptor(Class<?> clazz, EntityType<?> entityType, String tableName)
{
try
{
AbstractManagedType<?> ent = (AbstractManagedType<?>) entityType;
HTableDescriptor tableDescriptor = null;
String hTableName = HBaseUtils.getHTableName(databaseName, tableName);
tableDescriptor = !admin.tableExists(TableName.valueOf(hTableName)) ? new HTableDescriptor(
TableName.valueOf(hTableName)) : admin.getTableDescriptor(TableName.valueOf(hTableName));
addColumnFamilyAndSetProperties(tableDescriptor, tableName);
// Add column families for @SecondaryTable
List<String> secondaryTables = ((DefaultEntityAnnotationProcessor) ent.getEntityAnnotation())
.getSecondaryTablesName();
for (String secTable : secondaryTables)
{
addColumnFamilyAndSetProperties(tableDescriptor, secTable);
}
// handle @JoinTable for @ManyToMany
List<Relation> relations = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, clazz).getRelations();
addJoinTable(relations);
// @CollectionTable is not handled.
return tableDescriptor;
}
catch (IOException ex)
{
logger.error("Either table isn't in enabled state or some network problem, Caused by: ", ex);
throw new SchemaGenerationException(ex, "Hbase");
}
} | java | {
"resource": ""
} |
q163778 | HBaseSchemaManager.addJoinTable | train | private void addJoinTable(List<Relation> relations)
{
for (Relation relation : relations)
{
if (relation.getType().equals(ForeignKey.MANY_TO_MANY) && relation.isRelatedViaJoinTable())
{
String joinTableName = relation.getJoinTableMetadata().getJoinTableName();
String hTableName = HBaseUtils.getHTableName(databaseName, joinTableName);
HTableDescriptor tableDescriptor = new HTableDescriptor(TableName.valueOf(hTableName));
tableDescriptor.addFamily(new HColumnDescriptor(joinTableName));
createOrUpdateTable(hTableName, tableDescriptor);
}
}
} | java | {
"resource": ""
} |
q163779 | HBaseSchemaManager.addColumnFamilyAndSetProperties | train | private void addColumnFamilyAndSetProperties(HTableDescriptor tableDescriptor, String colFamilyName)
{
if (!tableDescriptor.hasFamily(colFamilyName.getBytes()))
{
HColumnDescriptor hColumnDescriptor = getColumnDescriptor(colFamilyName);
tableDescriptor.addFamily(hColumnDescriptor);
setExternalProperties(tableDescriptor.getNameAsString(), hColumnDescriptor);
}
} | java | {
"resource": ""
} |
q163780 | HBaseSchemaManager.setExternalProperties | train | private void setExternalProperties(String name, HColumnDescriptor hColumnDescriptor)
{
Properties properties = externalProperties != null ? externalProperties.get(name) : null;
if (properties != null && !properties.isEmpty())
{
for (Object obj : properties.keySet())
{
hColumnDescriptor
.setValue(Bytes.toBytes(obj.toString()), Bytes.toBytes(properties.get(obj).toString()));
}
}
} | java | {
"resource": ""
} |
q163781 | HBaseSchemaManager.createNamespace | train | private void createNamespace(boolean isUpdate)
{
boolean isNameSpaceAvailable = isNamespaceAvailable(databaseName);
if (isNameSpaceAvailable && !isUpdate)
{
drop();
}
if (!(isNameSpaceAvailable && isUpdate))
{
try
{
NamespaceDescriptor descriptor = NamespaceDescriptor.create(databaseName).build();
admin.createNamespace(descriptor);
}
catch (IOException ioex)
{
logger.error("Either table isn't in enabled state or some network problem, Caused by: ", ioex);
throw new SchemaGenerationException(ioex, "Hbase");
}
}
} | java | {
"resource": ""
} |
q163782 | HBaseSchemaManager.isNamespaceAvailable | train | private boolean isNamespaceAvailable(String databaseName)
{
try
{
for (NamespaceDescriptor ns : admin.listNamespaceDescriptors())
{
if (ns.getName().equals(databaseName))
{
return true;
}
}
return false;
}
catch (IOException ioex)
{
logger.error("Either table isn't in enabled state or some network problem, Caused by: ", ioex);
throw new SchemaGenerationException(ioex, "Either table isn't in enabled state or some network problem.");
}
} | java | {
"resource": ""
} |
q163783 | HBaseSchemaManager.createOrUpdateTable | train | private void createOrUpdateTable(String tablename, HTableDescriptor hTableDescriptor)
{
try
{
if (admin.isTableAvailable(tablename))
{
admin.modifyTable(tablename, hTableDescriptor);
}
else
{
admin.createTable(hTableDescriptor);
}
}
catch (IOException ioex)
{
logger.error("Either table isn't in enabled state or some network problem, Caused by: ", ioex);
throw new SchemaGenerationException(ioex, "Either table isn't in enabled state or some network problem.");
}
} | java | {
"resource": ""
} |
q163784 | HBaseSchemaManager.vaildateHostPort | train | private void vaildateHostPort(String host, String port)
{
if (host == null || !StringUtils.isNumeric(port) || port.isEmpty())
{
logger.error("Host or port should not be null / port should be numeric");
throw new IllegalArgumentException("Host or port should not be null / port should be numeric");
}
} | java | {
"resource": ""
} |
q163785 | HBaseSchemaManager.readExternalProperties | train | private void readExternalProperties()
{
schemas = HBasePropertyReader.hsmd.getDataStore() != null ? HBasePropertyReader.hsmd.getDataStore()
.getSchemas() : null;
List<Table> tables = null;
if (schemas != null && !schemas.isEmpty())
{
for (Schema s : schemas)
{
if (s.getName() != null && s.getName().equalsIgnoreCase(databaseName))
{
tables = s.getTables();
}
}
}
if (tables != null && !tables.isEmpty())
{
for (Table table : tables)
{
externalProperties.put(HBaseUtils.getHTableName(databaseName, table.getName()), table.getProperties());
}
}
} | java | {
"resource": ""
} |
q163786 | CouchDBUtils.closeContent | train | public static void closeContent(HttpResponse response)
{
if (response != null)
{
try
{
InputStream content = response.getEntity().getContent();
content.close();
}
catch (Exception e)
{
throw new KunderaException(e);
}
}
} | java | {
"resource": ""
} |
q163787 | CouchDBUtils.appendQuotes | train | static Object appendQuotes(Object value)
{
if (value instanceof String || value instanceof Character)
{
StringBuilder builder = new StringBuilder();
builder.append("\"");
builder.append(value);
builder.append("\"");
return builder.toString();
}
return value;
} | java | {
"resource": ""
} |
q163788 | CouchDBUtils.createDesignDocumentIfNotExist | train | public static void createDesignDocumentIfNotExist(HttpClient httpClient, HttpHost httpHost, Gson gson,
String tableName, String schemaName, String viewName, List<String> columns) throws URISyntaxException,
UnsupportedEncodingException, IOException, ClientProtocolException
{
URI uri;
HttpResponse response = null;
CouchDBDesignDocument designDocument = CouchDBUtils.getDesignDocument(httpClient, httpHost, gson, tableName,
schemaName);
Map<String, MapReduce> views = designDocument.getViews();
if (views == null)
{
views = new HashMap<String, MapReduce>();
}
if (views.get(viewName.toString()) == null)
{
CouchDBUtils.createView(views, viewName, columns);
}
String id = CouchDBConstants.DESIGN + tableName;
if (designDocument.get_rev() == null)
{
uri = new URI(CouchDBConstants.PROTOCOL, null, httpHost.getHostName(), httpHost.getPort(),
CouchDBConstants.URL_SEPARATOR + schemaName.toLowerCase() + CouchDBConstants.URL_SEPARATOR + id,
null, null);
}
else
{
StringBuilder builder = new StringBuilder("rev=");
builder.append(designDocument.get_rev());
uri = new URI(CouchDBConstants.PROTOCOL, null, httpHost.getHostName(), httpHost.getPort(),
CouchDBConstants.URL_SEPARATOR + schemaName.toLowerCase() + CouchDBConstants.URL_SEPARATOR + id,
builder.toString(), null);
}
HttpPut put = new HttpPut(uri);
designDocument.setViews(views);
String jsonObject = gson.toJson(designDocument);
StringEntity entity = new StringEntity(jsonObject);
put.setEntity(entity);
try
{
response = httpClient.execute(httpHost, put, CouchDBUtils.getContext(httpHost));
}
finally
{
CouchDBUtils.closeContent(response);
}
} | java | {
"resource": ""
} |
q163789 | CouchDBUtils.getDesignDocument | train | private static CouchDBDesignDocument getDesignDocument(HttpClient httpClient, HttpHost httpHost, Gson gson,
String tableName, String schemaName)
{
HttpResponse response = null;
try
{
String id = CouchDBConstants.DESIGN + tableName;
URI uri = new URI(CouchDBConstants.PROTOCOL, null, httpHost.getHostName(), httpHost.getPort(),
CouchDBConstants.URL_SEPARATOR + schemaName.toLowerCase() + CouchDBConstants.URL_SEPARATOR + id,
null, null);
HttpGet get = new HttpGet(uri);
get.addHeader("Accept", "application/json");
response = httpClient.execute(httpHost, get, CouchDBUtils.getContext(httpHost));
InputStream content = response.getEntity().getContent();
Reader reader = new InputStreamReader(content);
JsonObject jsonObject = gson.fromJson(reader, JsonObject.class);
return gson.fromJson(jsonObject, CouchDBDesignDocument.class);
}
catch (Exception e)
{
log.error("Error while fetching design document object, Caused by: .", e);
throw new KunderaException(e);
}
finally
{
CouchDBUtils.closeContent(response);
}
} | java | {
"resource": ""
} |
q163790 | OracleNoSQLSchemaManager.createIndexOnTable | train | private void createIndexOnTable(TableInfo tableInfo)
{
List<IndexInfo> indexColumns = tableInfo.getColumnsToBeIndexed();
for (IndexInfo indexInfo : indexColumns)
{
if (indexInfo.getIndexType() != null && indexInfo.getIndexType().toLowerCase().equals(Constants.COMPOSITE))
{
String[] columnNames = indexInfo.getColumnName().split(Constants.COMMA);
createIndex(tableInfo.getTableName(), indexInfo.getIndexName(), columnNames);
}
else
{
createIndex(tableInfo.getTableName(), indexInfo.getIndexName(), indexInfo.getColumnName());
}
}
} | java | {
"resource": ""
} |
q163791 | OracleNoSQLSchemaManager.buildCreateDDLQuery | train | private String buildCreateDDLQuery(TableInfo tableInfo)
{
String statement;
boolean flag = false;
StringBuilder compoundKeys = null;
StringBuilder builder = new StringBuilder();
builder.append("CREATE TABLE ");
builder.append(tableInfo.getTableName());
builder.append(Constants.OPEN_ROUND_BRACKET);
if (!tableInfo.getTableIdType().isAnnotationPresent(Embeddable.class))
{
builder.append(tableInfo.getIdColumnName());
builder.append(Constants.SPACE);
String idType = tableInfo.getTableIdType().getSimpleName().toLowerCase();
builder.append(OracleNoSQLValidationClassMapper.getValidIdType(idType));
builder.append(Constants.COMMA);
}
for (ColumnInfo columnInfo : tableInfo.getColumnMetadatas())
{
builder.append(columnInfo.getColumnName());
builder.append(Constants.SPACE);
String coulmnType = columnInfo.getType().getSimpleName().toLowerCase();
builder.append(OracleNoSQLValidationClassMapper.getValidType(coulmnType));
builder.append(Constants.COMMA);
}
for (EmbeddedColumnInfo embeddedColumnInfo : tableInfo.getEmbeddedColumnMetadatas())
{
if (tableInfo.getIdColumnName().equals(embeddedColumnInfo.getEmbeddedColumnName()))
{
compoundKeys = new StringBuilder();
flag = true;
}
for (ColumnInfo columnInfo : embeddedColumnInfo.getColumns())
{
builder.append(columnInfo.getColumnName());
builder.append(Constants.SPACE);
String coulmnType = columnInfo.getType().getSimpleName().toLowerCase();
builder.append(OracleNoSQLValidationClassMapper.getValidType(coulmnType));
builder.append(Constants.COMMA);
if (flag)
{
compoundKeys.append(columnInfo.getColumnName());
compoundKeys.append(Constants.COMMA);
}
}
flag = false;
}
builder.append("PRIMARY KEY");
builder.append(Constants.OPEN_ROUND_BRACKET);
if (!tableInfo.getTableIdType().isAnnotationPresent(Embeddable.class))
{
builder.append(tableInfo.getIdColumnName());
}
else
{
compoundKeys.deleteCharAt(compoundKeys.length() - 1);
builder.append(compoundKeys.toString());
}
builder.append(Constants.CLOSE_ROUND_BRACKET);
builder.append(Constants.CLOSE_ROUND_BRACKET);
statement = builder.toString();
return statement;
} | java | {
"resource": ""
} |
q163792 | OracleNoSQLSchemaManager.buildAlterDDLQuery | train | private String buildAlterDDLQuery(TableInfo tableInfo, Map<String, String> newColumns)
{
String statement;
StringBuilder builder = new StringBuilder();
builder.append("ALTER TABLE ");
builder.append(tableInfo.getTableName());
builder.append(Constants.OPEN_ROUND_BRACKET);
for (Map.Entry<String, String> entry : newColumns.entrySet())
{
builder.append("ADD ");
builder.append(entry.getKey());
builder.append(Constants.SPACE);
String coulmnType = entry.getValue().toLowerCase();
builder.append(OracleNoSQLValidationClassMapper.getValidType(coulmnType));
builder.append(Constants.COMMA);
}
builder.deleteCharAt(builder.length() - 1);
builder.append(Constants.CLOSE_ROUND_BRACKET);
statement = builder.toString();
return statement;
} | java | {
"resource": ""
} |
q163793 | GraphEntityMapper.createProxyNode | train | public Node createProxyNode(Object sourceNodeId, Object targetNodeId, GraphDatabaseService graphDb,
EntityMetadata sourceEntityMetadata, EntityMetadata targetEntityMetadata)
{
String sourceNodeIdColumnName = ((AbstractAttribute) sourceEntityMetadata.getIdAttribute()).getJPAColumnName();
String targetNodeIdColumnName = ((AbstractAttribute) targetEntityMetadata.getIdAttribute()).getJPAColumnName();
Node node = graphDb.createNode();
node.setProperty(PROXY_NODE_TYPE_KEY, PROXY_NODE_VALUE);
node.setProperty(sourceNodeIdColumnName, sourceNodeId);
node.setProperty(targetNodeIdColumnName, targetNodeId);
return node;
} | java | {
"resource": ""
} |
q163794 | GraphEntityMapper.populateNodeProperties | train | private void populateNodeProperties(Object entity, EntityMetadata m, Node node)
{
MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
m.getPersistenceUnit());
EntityType entityType = metaModel.entity(m.getEntityClazz());
// Iterate over entity attributes
Set<Attribute> attributes = entityType.getSingularAttributes();
for (Attribute attribute : attributes)
{
Field field = (Field) attribute.getJavaMember();
// Set Node level properties
if (!attribute.isCollection() && !attribute.isAssociation() && !((SingularAttribute) attribute).isId())
{
String columnName = ((AbstractAttribute) attribute).getJPAColumnName();
Object value = PropertyAccessorHelper.getObject(entity, field);
if (value != null)
{
node.setProperty(columnName, toNeo4JProperty(value));
}
}
}
} | java | {
"resource": ""
} |
q163795 | GraphEntityMapper.serializeIdAttributeValue | train | private String serializeIdAttributeValue(final EntityMetadata m, MetamodelImpl metaModel, Object id)
{
if (!metaModel.isEmbeddable(m.getIdAttribute().getBindableJavaType()))
{
return null;
}
Class<?> embeddableClass = m.getIdAttribute().getBindableJavaType();
String idUniqueValue = "";
for (Field embeddedField : embeddableClass.getDeclaredFields())
{
if (!ReflectUtils.isTransientOrStatic(embeddedField))
{
Object value = PropertyAccessorHelper.getObject(id, embeddedField);
if (value != null && !StringUtils.isEmpty(value.toString()))
idUniqueValue = idUniqueValue + value + COMPOSITE_KEY_SEPARATOR;
}
}
if (idUniqueValue.endsWith(COMPOSITE_KEY_SEPARATOR))
idUniqueValue = idUniqueValue.substring(0, idUniqueValue.length() - COMPOSITE_KEY_SEPARATOR.length());
return idUniqueValue;
} | java | {
"resource": ""
} |
q163796 | GraphEntityMapper.deserializeIdAttributeValue | train | private Object deserializeIdAttributeValue(final EntityMetadata m, String idValue)
{
if (idValue == null)
{
return null;
}
Class<?> embeddableClass = m.getIdAttribute().getBindableJavaType();
Object embeddedObject = embeddedObject = KunderaCoreUtils.createNewInstance(embeddableClass);
List<String> tokens = new ArrayList<String>();
StringTokenizer st = new StringTokenizer((String) idValue, COMPOSITE_KEY_SEPARATOR);
while (st.hasMoreTokens())
{
tokens.add((String) st.nextElement());
}
int count = 0;
for (Field embeddedField : embeddableClass.getDeclaredFields())
{
if (!ReflectUtils.isTransientOrStatic(embeddedField))
{
if (count < tokens.size())
{
String value = tokens.get(count++);
PropertyAccessorHelper.set(embeddedObject, embeddedField, value);
}
}
}
return embeddedObject;
} | java | {
"resource": ""
} |
q163797 | GraphEntityMapper.toNeo4JProperty | train | public Object toNeo4JProperty(Object source)
{
if (source instanceof BigDecimal || source instanceof BigInteger)
{
return source.toString();
}
else if ((source instanceof Calendar) || (source instanceof GregorianCalendar))
{
return PropertyAccessorHelper.fromSourceToTargetClass(String.class, Date.class,
((Calendar) source).getTime());
}
if (source instanceof Date)
{
Class<?> sourceClass = source.getClass();
return PropertyAccessorHelper.fromSourceToTargetClass(String.class, sourceClass, source);
}
return source;
} | java | {
"resource": ""
} |
q163798 | GraphEntityMapper.searchNode | train | public Node searchNode(Object key, EntityMetadata m, GraphDatabaseService graphDb, boolean skipProxy)
{
Node node = null;
String idColumnName = ((AbstractAttribute) m.getIdAttribute()).getJPAColumnName();
final MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
m.getPersistenceUnit());
if (metaModel.isEmbeddable(m.getIdAttribute().getBindableJavaType()))
{
key = serializeIdAttributeValue(m, metaModel, key);
}
if (indexer.isNodeAutoIndexingEnabled(graphDb))
{
// Get the Node auto index
ReadableIndex<Node> autoNodeIndex = graphDb.index().getNodeAutoIndexer().getAutoIndex();
IndexHits<Node> nodesFound = autoNodeIndex.get(idColumnName, key);
node = getMatchingNodeFromIndexHits(nodesFound, skipProxy);
}
else
{
// Searching within manually created indexes
Index<Node> nodeIndex = graphDb.index().forNodes(m.getIndexName());
IndexHits<Node> nodesFound = nodeIndex.get(idColumnName, key);
node = getMatchingNodeFromIndexHits(nodesFound, skipProxy);
}
return node;
} | java | {
"resource": ""
} |
q163799 | GraphEntityMapper.getMatchingNodeFromIndexHits | train | protected Node getMatchingNodeFromIndexHits(IndexHits<Node> nodesFound, boolean skipProxy)
{
Node node = null;
try
{
if (nodesFound == null || nodesFound.size() == 0 || !nodesFound.hasNext())
{
return null;
}
else
{
if (skipProxy)
node = getNonProxyNode(nodesFound);
else
node = nodesFound.next();
}
}
finally
{
nodesFound.close();
}
return node;
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.