_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q164400 | SchemaConfiguration.getSchemaManagerForPu | train | private SchemaManager getSchemaManagerForPu(final String persistenceUnit)
{
SchemaManager schemaManager = null;
Map<String, Object> externalProperties = KunderaCoreUtils.getExternalProperties(persistenceUnit,
externalPropertyMap, persistenceUnits);
if (getSchemaProperty(persistenceUnit, externalProperties) != null
&& !getSchemaProperty(persistenceUnit, externalProperties).isEmpty())
{
ClientFactory clientFactory = ClientResolver.getClientFactory(persistenceUnit);
schemaManager = clientFactory != null ? clientFactory.getSchemaManager(externalProperties) : null;
}
return schemaManager;
} | java | {
"resource": ""
} |
q164401 | SchemaConfiguration.addTableGenerator | train | private void addTableGenerator(ApplicationMetadata appMetadata, String persistenceUnit, List<TableInfo> tableInfos,
EntityMetadata entityMetadata)
{
Metamodel metamodel = appMetadata.getMetamodel(persistenceUnit);
IdDiscriptor keyValue = ((MetamodelImpl) metamodel).getKeyValue(entityMetadata.getEntityClazz().getName());
if (keyValue != null && keyValue.getTableDiscriptor() != null)
{
TableInfo tableGeneratorDiscriptor = new TableInfo(keyValue.getTableDiscriptor().getTable(),
"CounterColumnType", String.class, keyValue.getTableDiscriptor().getPkColumnName());
if (!tableInfos.contains(tableGeneratorDiscriptor))
{
tableGeneratorDiscriptor.addColumnInfo(getJoinColumn(tableGeneratorDiscriptor,
keyValue.getTableDiscriptor().getValueColumnName(), Long.class));
tableInfos.add(tableGeneratorDiscriptor);
}
}
} | java | {
"resource": ""
} |
q164402 | SchemaConfiguration.addJoinColumnToInfo | train | private void addJoinColumnToInfo(String joinColumn, TableInfo targetTableInfo, List<TableInfo> targetTableInfos,
EntityMetadata m)
{
if (!joinColumn.equals(targetTableInfo.getIdColumnName()))
{
if (!targetTableInfos.isEmpty() && targetTableInfos.contains(targetTableInfo))
{
int idx = targetTableInfos.indexOf(targetTableInfo);
targetTableInfo = targetTableInfos.get(idx);
ColumnInfo columnInfoOfJoinColumn = getJoinColumn(targetTableInfo, joinColumn,
m.getIdAttribute().getBindableJavaType());
if (!targetTableInfo.getColumnMetadatas().contains(columnInfoOfJoinColumn))
{
targetTableInfo.addColumnInfo(columnInfoOfJoinColumn);
}
}
else
{
ColumnInfo columnInfoOfJoinColumn = getJoinColumn(targetTableInfo, joinColumn,
m.getIdAttribute().getBindableJavaType());
if (!targetTableInfo.getColumnMetadatas().contains(columnInfoOfJoinColumn))
{
targetTableInfo.addColumnInfo(columnInfoOfJoinColumn);
}
targetTableInfos.add(targetTableInfo);
}
}
} | java | {
"resource": ""
} |
q164403 | SchemaConfiguration.getEmbeddedColumn | train | private EmbeddedColumnInfo getEmbeddedColumn(TableInfo tableInfo, EmbeddableType embeddableType,
String embeddableColName, Class embeddedEntityClass, Field field)
{
String[] orderByColumns = null;
if (field.isAnnotationPresent(OrderBy.class))
{
OrderBy order = (OrderBy) field.getAnnotation(OrderBy.class);
orderByColumns = order.value().split("\\s*,\\s*");
}
EmbeddedColumnInfo embeddedColumnInfo = new EmbeddedColumnInfo(embeddableType);
embeddedColumnInfo.setEmbeddedColumnName(embeddableColName);
Map<String, PropertyIndex> indexedColumns = IndexProcessor.getIndexesOnEmbeddable(embeddedEntityClass);
List<ColumnInfo> columns = new ArrayList<ColumnInfo>();
Set attributes = embeddableType.getAttributes();
Iterator<Attribute> iter = attributes.iterator();
while (iter.hasNext())
{
Attribute attr = iter.next();
columns.add(getColumn(tableInfo, attr, indexedColumns.get(attr.getName()), orderByColumns));
}
embeddedColumnInfo.setColumns(columns);
return embeddedColumnInfo;
} | java | {
"resource": ""
} |
q164404 | SchemaConfiguration.getColumn | train | private ColumnInfo getColumn(TableInfo tableInfo, Attribute column, PropertyIndex indexedColumn,
String[] orderByColumns)
{
ColumnInfo columnInfo = new ColumnInfo();
if (column.getJavaType().isAnnotationPresent(OrderBy.class))
{
OrderBy order = (OrderBy) column.getJavaType().getAnnotation(OrderBy.class);
orderByColumns = order.value().split("\\s*,\\s*");
}
columnInfo.setOrderBy(getOrderByColumn(orderByColumns, column));
if (column.getJavaType().isEnum())
{
columnInfo.setType(String.class);
}
else
{
columnInfo.setType(column.getJavaType());
}
columnInfo.setColumnName(((AbstractAttribute) column).getJPAColumnName());
if (indexedColumn != null && indexedColumn.getName() != null)
{
columnInfo.setIndexable(true);
IndexInfo indexInfo = new IndexInfo(((AbstractAttribute) column).getJPAColumnName(), indexedColumn.getMax(),
indexedColumn.getMin(), indexedColumn.getIndexType(), indexedColumn.getName());
tableInfo.addToIndexedColumnList(indexInfo);
// Add more if required
}
return columnInfo;
} | java | {
"resource": ""
} |
q164405 | SchemaConfiguration.getOrderByColumn | train | private String getOrderByColumn(String[] orderByColumns, Attribute column)
{
if (orderByColumns != null)
{
for (String orderColumn : orderByColumns)
{
String[] orderValue = orderColumn.split("\\s");
String orderColumnName = orderValue[0].substring(orderValue[0].lastIndexOf('.') + 1);
String orderColumnValue = orderValue[1];
if (orderColumnName.equals(((AbstractAttribute) column).getName())
|| orderColumnName.equals(((AbstractAttribute) column).getJPAColumnName()))
{
return orderColumnValue;
}
}
}
return null;
} | java | {
"resource": ""
} |
q164406 | SchemaConfiguration.getJoinColumn | train | private ColumnInfo getJoinColumn(TableInfo tableInfo, String joinColumnName, Class columnType)
{
ColumnInfo columnInfo = new ColumnInfo();
columnInfo.setColumnName(joinColumnName);
columnInfo.setIndexable(true);
IndexInfo indexInfo = new IndexInfo(joinColumnName);
tableInfo.addToIndexedColumnList(indexInfo);
columnInfo.setType(columnType);
return columnInfo;
} | java | {
"resource": ""
} |
q164407 | SchemaConfiguration.getSchemaProperty | train | private String getSchemaProperty(String persistenceUnit, Map<String, Object> externalProperties)
{
PersistenceUnitMetadata persistenceUnitMetadata = kunderaMetadata.getApplicationMetadata()
.getPersistenceUnitMetadata(persistenceUnit);
String autoDdlOption = externalProperties != null
? (String) externalProperties.get(PersistenceProperties.KUNDERA_DDL_AUTO_PREPARE) : null;
if (autoDdlOption == null)
{
autoDdlOption = persistenceUnitMetadata != null
? persistenceUnitMetadata.getProperty(PersistenceProperties.KUNDERA_DDL_AUTO_PREPARE) : null;
}
return autoDdlOption;
} | java | {
"resource": ""
} |
q164408 | PropertyAccessorFactory.getPropertyAccessor | train | @SuppressWarnings("unchecked")
public static PropertyAccessor getPropertyAccessor(Class<?> clazz)
{
PropertyAccessor<?> accessor;
if (clazz.isEnum())
{
accessor = new EnumAccessor();
}
else
{
accessor = map.get(clazz);
}
// allow fall-back to Object streamer.
if (null == accessor)
{
if (Enum.class.isAssignableFrom(clazz))
{
accessor = map.get(Enum.class);
}
else
{
accessor = map.get(Object.class);
}
}
return accessor;
} | java | {
"resource": ""
} |
q164409 | CQLTranslator.prepareColumnOrColumnValues | train | public HashMap<TranslationType, Map<String, StringBuilder>> prepareColumnOrColumnValues(final Object record,
final EntityMetadata entityMetadata, TranslationType type, Map<String, Object> externalProperties,
final KunderaMetadata kunderaMetadata)
{
HashMap<TranslationType, Map<String, StringBuilder>> parsedColumnOrColumnValue = new HashMap<CQLTranslator.TranslationType, Map<String, StringBuilder>>();
if (type == null)
{
throw new TranslationException("Please specify TranslationType: either COLUMN or VALUE");
}
MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
entityMetadata.getPersistenceUnit());
Class entityClazz = entityMetadata.getEntityClazz();
EntityType entityType = metaModel.entity(entityClazz);
Map<String, StringBuilder> builders = new HashMap<String, StringBuilder>();
Map<String, StringBuilder> columnBuilders = new HashMap<String, StringBuilder>();
onTranslation(record, entityMetadata, type, metaModel, entityClazz, entityType, builders, columnBuilders,
externalProperties, kunderaMetadata);
for (String tableName : columnBuilders.keySet())
{
StringBuilder builder = builders.get(tableName);
StringBuilder columnBuilder = columnBuilders.get(tableName);
if (type.equals(TranslationType.ALL) || type.equals(TranslationType.VALUE))
{
builder.deleteCharAt(builder.length() - 1);
}
if (type.equals(TranslationType.ALL) || type.equals(TranslationType.COLUMN))
{
columnBuilder.deleteCharAt(columnBuilder.length() - 1);
}
}
parsedColumnOrColumnValue.put(TranslationType.COLUMN, columnBuilders);
parsedColumnOrColumnValue.put(TranslationType.VALUE, builders);
return parsedColumnOrColumnValue;
} | java | {
"resource": ""
} |
q164410 | CQLTranslator.buildEmbeddedValue | train | private void buildEmbeddedValue(final Object record, MetamodelImpl metaModel, StringBuilder embeddedValueBuilder,
SingularAttribute attribute)
{
// TODO Auto-generated method stub
Field field = (Field) attribute.getJavaMember();
EmbeddableType embeddableKey = metaModel.embeddable(field.getType());
Object embeddableKeyObj = PropertyAccessorHelper.getObject(record, field);
if (embeddableKeyObj != null)
{
StringBuilder tempBuilder = new StringBuilder();
tempBuilder.append(Constants.OPEN_CURLY_BRACKET);
for (Field embeddableColumn : field.getType().getDeclaredFields())
{
if (!ReflectUtils.isTransientOrStatic(embeddableColumn))
{
Attribute subAttribute = (SingularAttribute) embeddableKey.getAttribute(embeddableColumn.getName());
if (metaModel.isEmbeddable(((AbstractAttribute) subAttribute).getBindableJavaType()))
{
// construct map; recursive
// send attribute
buildEmbeddedValue(embeddableKeyObj, metaModel, tempBuilder, (SingularAttribute) subAttribute);
}
else
{
// append key value
appendColumnName(tempBuilder, ((AbstractAttribute) (embeddableKey.getAttribute(embeddableColumn
.getName()))).getJPAColumnName());
tempBuilder.append(Constants.COLON);
appendColumnValue(tempBuilder, embeddableKeyObj, embeddableColumn);
}
tempBuilder.append(Constants.COMMA);
}
}
// strip last char and append '}'
tempBuilder.deleteCharAt(tempBuilder.length() - 1);
tempBuilder.append(Constants.CLOSE_CURLY_BRACKET);
appendColumnName(embeddedValueBuilder, ((AbstractAttribute) attribute).getJPAColumnName());
embeddedValueBuilder.append(Constants.COLON);
embeddedValueBuilder.append(tempBuilder);
}
else
{
embeddedValueBuilder.deleteCharAt(embeddedValueBuilder.length() - 1);
}
} | java | {
"resource": ""
} |
q164411 | CQLTranslator.translateCompositeId | train | private void translateCompositeId(final Object record, final EntityMetadata m, TranslationType type,
MetamodelImpl metaModel, Map<String, StringBuilder> builders, Map<String, StringBuilder> columnBuilders,
Map<String, Object> externalProperties, final KunderaMetadata kunderaMetadata, String tableName,
SingularAttribute attribute)
{
StringBuilder builder = builders.get(tableName);
StringBuilder columnBuilder = columnBuilders.get(tableName);
Field field = (Field) attribute.getJavaMember();
if (metaModel.isEmbeddable(((AbstractAttribute) attribute).getBindableJavaType()))
{
// builder.
// Means it is a compound key! As other
// iterate for it's fields to populate it's values in
// order!
EmbeddableType compoundKey = metaModel.embeddable(field.getType());
Object compoundKeyObj = PropertyAccessorHelper.getObject(record, field);
for (Field compositeColumn : field.getType().getDeclaredFields())
{
if (!ReflectUtils.isTransientOrStatic(compositeColumn))
{
attribute = (SingularAttribute) compoundKey.getAttribute(compositeColumn.getName());
if (metaModel.isEmbeddable(((AbstractAttribute) attribute).getBindableJavaType()))
{
translateCompositeId(compoundKeyObj, m, type, metaModel, builders, columnBuilders,
externalProperties, kunderaMetadata, tableName, attribute);
}
else
{
onTranslation(type, builder, columnBuilder,
((AbstractAttribute) (compoundKey.getAttribute(compositeColumn.getName())))
.getJPAColumnName(), compoundKeyObj, compositeColumn);
}
}
}
}
else if (!ReflectUtils.isTransientOrStatic(field))
{
onTranslation(type, builder, columnBuilder,
CassandraUtilities.getIdColumnName(kunderaMetadata, m, externalProperties, true), record, field);
}
} | java | {
"resource": ""
} |
q164412 | CQLTranslator.buildSetClauseForCounters | train | public void buildSetClauseForCounters(StringBuilder builder, String field, Object value)
{
builder = ensureCase(builder, field, false);
builder.append(EQ_CLAUSE);
builder = ensureCase(builder, field, false);
builder.append(INCR_COUNTER);
appendValue(builder, value.getClass(), value, false, false);
builder.append(COMMA_STR);
} | java | {
"resource": ""
} |
q164413 | CQLTranslator.buildSetClause | train | public void buildSetClause(EntityMetadata m, StringBuilder builder, String property, Object value)
{
builder = ensureCase(builder, property, false);
builder.append(EQ_CLAUSE);
if (m.isCounterColumnType())
{
builder = ensureCase(builder, property, false);
builder.append(INCR_COUNTER);
builder.append(value);
}
else
{
appendValue(builder, value.getClass(), value, false, false);
}
builder.append(COMMA_STR);
} | java | {
"resource": ""
} |
q164414 | CQLTranslator.ensureCase | train | public StringBuilder ensureCase(StringBuilder builder, String fieldName, boolean useToken)
{
if (useToken)
{
builder.append(TOKEN);
}
builder.append(Constants.ESCAPE_QUOTE);
builder.append(fieldName);
builder.append(Constants.ESCAPE_QUOTE);
if (useToken)
{
builder.append(CLOSE_BRACKET);
}
return builder;
} | java | {
"resource": ""
} |
q164415 | CQLTranslator.appendColumnValue | train | private boolean appendColumnValue(StringBuilder builder, Object valueObj, Field column)
{
Object value = PropertyAccessorHelper.getObject(valueObj, column);
boolean isPresent = false;
isPresent = appendValue(builder, column.getType(), value, isPresent, false);
return isPresent;
} | java | {
"resource": ""
} |
q164416 | CQLTranslator.appendValue | train | public boolean appendValue(StringBuilder builder, Class fieldClazz, Object value, boolean isPresent,
boolean useToken)
{
if (List.class.isAssignableFrom(fieldClazz))
{
isPresent = appendList(builder, value != null ? value : new ArrayList());
}
else if (Set.class.isAssignableFrom(fieldClazz))
{
isPresent = appendSet(builder, value != null ? value : new HashSet());
}
else if (Map.class.isAssignableFrom(fieldClazz))
{
isPresent = appendMap(builder, value != null ? value : new HashMap());
}
else
{
isPresent = true;
appendValue(builder, fieldClazz, value, useToken);
}
return isPresent;
} | java | {
"resource": ""
} |
q164417 | CQLTranslator.appendColumnName | train | public void appendColumnName(StringBuilder builder, String columnName, String dataType)
{
ensureCase(builder, columnName, false);
builder.append(" "); // because only key columns
builder.append(dataType);
} | java | {
"resource": ""
} |
q164418 | CQLTranslator.isDate | train | private boolean isDate(Class clazz)
{
return clazz.isAssignableFrom(Date.class) || clazz.isAssignableFrom(java.sql.Date.class)
|| clazz.isAssignableFrom(Timestamp.class) || clazz.isAssignableFrom(Time.class)
|| clazz.isAssignableFrom(Calendar.class);
} | java | {
"resource": ""
} |
q164419 | CQLTranslator.buildOrderByClause | train | public void buildOrderByClause(StringBuilder builder, String field, Object orderType, boolean useToken)
{
builder.append(SPACE_STRING);
builder.append(SORT_CLAUSE);
builder = ensureCase(builder, field, useToken);
builder.append(SPACE_STRING);
builder.append(orderType);
} | java | {
"resource": ""
} |
q164420 | CQLTranslator.buildSelectQuery | train | public StringBuilder buildSelectQuery(TableGeneratorDiscriptor descriptor)
{
StringBuilder builder = new StringBuilder("Select ");
ensureCase(builder, descriptor.getValueColumnName(), false).append(" from ");
ensureCase(builder, descriptor.getTable(), false).append(" where ");
ensureCase(builder, descriptor.getPkColumnName(), false).append(" = '").append(
descriptor.getPkColumnValue() + "'");
return builder;
} | java | {
"resource": ""
} |
q164421 | EntityListenersProcessor.addCallBackMethod | train | @SuppressWarnings("unchecked")
private void addCallBackMethod(EntityMetadata metadata, Class<?> jpaAnnotation, CallbackMethod callbackMethod)
{
Map<Class<?>, List<? extends CallbackMethod>> callBackMethodsMap = metadata.getCallbackMethodsMap();
List<CallbackMethod> list = (List<CallbackMethod>) callBackMethodsMap.get(jpaAnnotation);
if (null == list)
{
list = new ArrayList<CallbackMethod>();
callBackMethodsMap.put(jpaAnnotation, list);
}
list.add(callbackMethod);
} | java | {
"resource": ""
} |
q164422 | EntityListenersProcessor.getValidJPAAnnotationsFromMethod | train | private List<Class<?>> getValidJPAAnnotationsFromMethod(Class<?> clazz, Method method, int numberOfParams,
Class<?> entityClazz)
{
List<Class<?>> annotations = new ArrayList<Class<?>>();
for (Annotation methodAnnotation : method.getAnnotations())
{
Class<?> methodAnnotationType = methodAnnotation.annotationType();
if (isValidJPAEntityListenerAnnotation(methodAnnotationType))
{
// verify method signature
// verify exceptions
boolean hasUncheckedExceptions = false;
for (Class<?> exception : method.getExceptionTypes())
{
if (!ReflectUtils.hasSuperClass(RuntimeException.class, exception))
{
hasUncheckedExceptions = true;
break;
}
}
if (hasUncheckedExceptions)
{
log.info("Skipped method(" + clazz.getName() + "." + method.getName()
+ ") Must not throw unchecked exceptions.");
continue;
}
// return type must be "void"
if (!method.getReturnType().getSimpleName().equals("void"))
{
log.info("Skipped method(" + clazz.getName() + "." + method.getName()
+ ") Must have \"void\" return type.");
continue;
}
// argument must be an Entity or Object
Class<?>[] paramTypes = method.getParameterTypes();
if (paramTypes.length != numberOfParams)
{
log.info("Skipped method(" + clazz.getName() + "." + method.getName() + ") Must have "
+ numberOfParams + " parameter.");
continue;
}
if (numberOfParams == 1)
{
Class<?> parameter = paramTypes[0];
if (!(parameter != null && parameter.isAssignableFrom(entityClazz)))
{
log.info("Skipped method(" + clazz.getName() + "." + method.getName()
+ ") Must have only 1 \"Object\" type parameter.");
continue;
}
}
annotations.add(methodAnnotationType);
}
}
return annotations;
} | java | {
"resource": ""
} |
q164423 | ThriftClientFactory.getPoolUsingPolicy | train | private ConnectionPool getPoolUsingPolicy()
{
if (!hostPools.isEmpty())
{
return (ConnectionPool) loadBalancingPolicy.getPool(hostPools.values());
}
throw new KunderaException("All hosts are down. please check servers manully.");
} | java | {
"resource": ""
} |
q164424 | ThriftClientFactory.getNewPool | train | private ConnectionPool getNewPool(String host, int port)
{
CassandraHost cassandraHost = ((CassandraHostConfiguration) configuration).getCassandraHost(host, port);
hostPools.remove(cassandraHost);
if (cassandraHost.isRetryHost())
{
logger.warn("Scheduling node for future retry");
((CassandraRetryService) hostRetryService).add((CassandraHost) cassandraHost);
}
return getPoolUsingPolicy();
} | java | {
"resource": ""
} |
q164425 | ThriftClientFactory.releaseConnection | train | void releaseConnection(ConnectionPool pool, Cassandra.Client conn)
{
if (pool != null && conn != null)
{
pool.release(conn);
}
} | java | {
"resource": ""
} |
q164426 | DSClientFactory.getPolicyInstance | train | private LoadBalancingPolicy getPolicyInstance(BalancingPolicy policy, Properties conProperties)
{
LoadBalancingPolicy loadBalancingPolicy = null;
String isTokenAware = (String) conProperties.get("isTokenAware");
String isLatencyAware = (String) conProperties.get("isLatencyAware");
String whiteList = (String) conProperties.get("whiteList");
String hostFilterPolicy = (String) conProperties.get("hostFilterPolicy");
// Policy.v
switch (policy)
{
case DCAwareRoundRobinPolicy:
String usedHostsPerRemoteDc = (String) conProperties.get("usedHostsPerRemoteDc");
String localdc = (String) conProperties.get("localdc");
String allowRemoteDCsForLocalConsistencyLevel = (String) conProperties
.get("allowRemoteDCsForLocalConsistencyLevel");
DCAwareRoundRobinPolicy.Builder policyBuilder = DCAwareRoundRobinPolicy.builder();
policyBuilder.withLocalDc(localdc == null ? "DC1" : localdc);
policyBuilder.withUsedHostsPerRemoteDc(usedHostsPerRemoteDc != null ? Integer
.parseInt(usedHostsPerRemoteDc) : 0);
if (allowRemoteDCsForLocalConsistencyLevel != null
&& "true".equalsIgnoreCase(allowRemoteDCsForLocalConsistencyLevel))
{
policyBuilder.allowRemoteDCsForLocalConsistencyLevel();
}
loadBalancingPolicy = policyBuilder.build();
break;
// case RoundRobinPolicy:
// loadBalancingPolicy = new RoundRobinPolicy();
// break;
default:
// default is RoundRobinPolicy
loadBalancingPolicy = new RoundRobinPolicy();
break;
}
if (loadBalancingPolicy != null && Boolean.valueOf(isTokenAware))
{
loadBalancingPolicy = new TokenAwarePolicy(loadBalancingPolicy);
}
else if (loadBalancingPolicy != null && Boolean.valueOf(isLatencyAware))
{
loadBalancingPolicy = LatencyAwarePolicy.builder(loadBalancingPolicy).build();
}
if (loadBalancingPolicy != null && whiteList != null)
{
Collection<InetSocketAddress> whiteListCollection = buildWhiteListCollection(whiteList);
loadBalancingPolicy = new WhiteListPolicy(loadBalancingPolicy, whiteListCollection);
}
if (loadBalancingPolicy != null && hostFilterPolicy != null)
{
Predicate<com.datastax.driver.core.Host> predicate = getHostFilterPredicate(hostFilterPolicy);
loadBalancingPolicy = new HostFilterPolicy(loadBalancingPolicy, predicate);
}
return loadBalancingPolicy;
} | java | {
"resource": ""
} |
q164427 | DSClientFactory.getHostFilterPredicate | train | private Predicate<com.datastax.driver.core.Host> getHostFilterPredicate(String hostFilterPolicy)
{
Predicate<com.datastax.driver.core.Host> predicate = null;
Method getter = null;
Class<?> hostFilterClazz = null;
try
{
hostFilterClazz = Class.forName(hostFilterPolicy);
getter = hostFilterClazz.getDeclaredMethod(GET_INSTANCE);
predicate = (Predicate<com.datastax.driver.core.Host>) getter.invoke(KunderaCoreUtils
.createNewInstance(hostFilterClazz));
}
catch (ClassNotFoundException e)
{
logger.error(e.getMessage());
throw new KunderaException("Please make sure class " + hostFilterPolicy
+ " set in property file exists in classpath " + e.getMessage());
}
catch (IllegalAccessException e)
{
logger.error(e.getMessage());
throw new KunderaException("Method " + getter.getName() + " must be declared public " + e.getMessage());
}
catch (NoSuchMethodException e)
{
logger.error(e.getMessage());
throw new KunderaException("Please make sure getter method of " + hostFilterClazz.getSimpleName()
+ " is named \"getInstance()\"");
}
catch (InvocationTargetException e)
{
logger.error(e.getMessage());
throw new KunderaException("Error while executing \"getInstance()\" method of Class "
+ hostFilterClazz.getSimpleName() + ": " + e.getMessage());
}
catch (SecurityException e)
{
logger.error(e.getMessage());
throw new KunderaException("Encountered security exception while accessing the method: "
+ "\"getInstance()\"" + e.getMessage());
}
return predicate;
} | java | {
"resource": ""
} |
q164428 | DSClientFactory.buildWhiteListCollection | train | private Collection<InetSocketAddress> buildWhiteListCollection(String whiteList)
{
String[] list = whiteList.split(Constants.COMMA);
Collection<InetSocketAddress> whiteListCollection = new ArrayList<InetSocketAddress>();
PersistenceUnitMetadata persistenceUnitMetadata = kunderaMetadata.getApplicationMetadata()
.getPersistenceUnitMetadata(getPersistenceUnit());
Properties props = persistenceUnitMetadata.getProperties();
int defaultPort = 9042;
if (externalProperties != null && externalProperties.get(PersistenceProperties.KUNDERA_PORT) != null)
{
try
{
defaultPort = Integer.parseInt((String) externalProperties.get(PersistenceProperties.KUNDERA_PORT));
}
catch (NumberFormatException e)
{
logger.error("Port in persistence.xml should be integer");
}
}
else
{
try
{
defaultPort = Integer.parseInt((String) props.get(PersistenceProperties.KUNDERA_PORT));
}
catch (NumberFormatException e)
{
logger.error("Port in persistence.xml should be integer");
}
}
for (String node : list)
{
if (node.indexOf(Constants.COLON) > 0)
{
String[] parts = node.split(Constants.COLON);
whiteListCollection.add(new InetSocketAddress(parts[0], Integer.parseInt(parts[1])));
}
else
{
whiteListCollection.add(new InetSocketAddress(node, defaultPort));
}
}
return whiteListCollection;
} | java | {
"resource": ""
} |
q164429 | DSClientFactory.getCustomRetryPolicy | train | private com.datastax.driver.core.policies.RetryPolicy getCustomRetryPolicy(Properties props)
{
String customRetryPolicy = (String) props.get(CUSTOM_RETRY_POLICY);
Class<?> clazz = null;
Method getter = null;
try
{
clazz = Class.forName(customRetryPolicy);
com.datastax.driver.core.policies.RetryPolicy retryPolicy = (com.datastax.driver.core.policies.RetryPolicy) KunderaCoreUtils
.createNewInstance(clazz);
if (retryPolicy != null)
{
return retryPolicy;
}
getter = clazz.getDeclaredMethod(GET_INSTANCE);
return (com.datastax.driver.core.policies.RetryPolicy) getter.invoke(null, (Object[]) null);
}
catch (ClassNotFoundException e)
{
logger.error(e.getMessage());
throw new KunderaException("Please make sure class " + customRetryPolicy
+ " set in property file exists in classpath " + e.getMessage());
}
catch (IllegalAccessException e)
{
logger.error(e.getMessage());
throw new KunderaException("Method " + getter.getName() + " must be declared public " + e.getMessage());
}
catch (NoSuchMethodException e)
{
logger.error(e.getMessage());
throw new KunderaException("Please make sure getter method of " + clazz.getSimpleName()
+ " is named \"getInstance()\"");
}
catch (InvocationTargetException e)
{
logger.error(e.getMessage());
throw new KunderaException("Error while executing \"getInstance()\" method of Class "
+ clazz.getSimpleName() + ": " + e.getMessage());
}
} | java | {
"resource": ""
} |
q164430 | DSClientFactory.getSocketOptions | train | private SocketOptions getSocketOptions(Properties connectionProperties)
{
// SocketOptions
SocketOptions socketConfig = new SocketOptions();
String connectTimeoutMillis = connectionProperties.getProperty(CassandraConstants.SOCKET_TIMEOUT);
String readTimeoutMillis = connectionProperties.getProperty("readTimeoutMillis");
String keepAlive = connectionProperties.getProperty("keepAlive");
String reuseAddress = connectionProperties.getProperty("reuseAddress");
String soLinger = connectionProperties.getProperty("soLinger");
String tcpNoDelay = connectionProperties.getProperty("tcpNoDelay");
String receiveBufferSize = connectionProperties.getProperty("receiveBufferSize");
String sendBufferSize = connectionProperties.getProperty("sendBufferSize");
if (!StringUtils.isBlank(connectTimeoutMillis))
{
socketConfig.setConnectTimeoutMillis(new Integer(connectTimeoutMillis));
}
if (!StringUtils.isBlank(readTimeoutMillis))
{
socketConfig.setReadTimeoutMillis(new Integer(readTimeoutMillis));
}
if (!StringUtils.isBlank(keepAlive))
{
socketConfig.setKeepAlive(new Boolean(keepAlive));
}
if (!StringUtils.isBlank(reuseAddress))
{
socketConfig.setReuseAddress(new Boolean(reuseAddress));
}
if (!StringUtils.isBlank(soLinger))
{
socketConfig.setSoLinger(new Integer(soLinger));
}
if (!StringUtils.isBlank(tcpNoDelay))
{
socketConfig.setTcpNoDelay(new Boolean(tcpNoDelay));
}
if (!StringUtils.isBlank(receiveBufferSize))
{
socketConfig.setReceiveBufferSize(new Integer(receiveBufferSize));
}
if (!StringUtils.isBlank(sendBufferSize))
{
socketConfig.setSendBufferSize(new Integer(sendBufferSize));
}
return socketConfig;
} | java | {
"resource": ""
} |
q164431 | DSClientFactory.getPoolingOptions | train | private PoolingOptions getPoolingOptions(Properties connectionProperties)
{
// minSimultaneousRequests, maxSimultaneousRequests, coreConnections,
// maxConnections
PoolingOptions options = new PoolingOptions();
String hostDistance = connectionProperties.getProperty("hostDistance");
String maxConnectionsPerHost = connectionProperties.getProperty("maxConnectionsPerHost");
String maxRequestsPerConnection = connectionProperties.getProperty("maxRequestsPerConnection");
String coreConnections = connectionProperties.getProperty("coreConnections");
if (!StringUtils.isBlank(hostDistance))
{
HostDistance hostDist = HostDistance.valueOf(hostDistance.toUpperCase());
if (!StringUtils.isBlank(coreConnections))
{
options.setCoreConnectionsPerHost(HostDistance.LOCAL, new Integer(coreConnections));
}
if (!StringUtils.isBlank(maxConnectionsPerHost))
{
options.setMaxConnectionsPerHost(hostDist, new Integer(maxConnectionsPerHost));
}
if (!StringUtils.isBlank(maxRequestsPerConnection))
{
options.setMaxRequestsPerConnection(hostDist, new Integer(maxRequestsPerConnection));
}
}
return options;
} | java | {
"resource": ""
} |
q164432 | HBaseQuery.getBytes | train | private byte[] getBytes(String jpaFieldName, EntityMetadata m, Object value)
{
AbstractAttribute idCol = (AbstractAttribute) m.getIdAttribute();
MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
m.getPersistenceUnit());
EntityType entity = metaModel.entity(m.getEntityClazz());
Class fieldClazz = null;
if (idCol.getName().equals(jpaFieldName))
{
Field f = (Field) idCol.getJavaMember();
if (metaModel.isEmbeddable(idCol.getBindableJavaType()))
{
fieldClazz = String.class;
Map<Attribute, List<Object>> columnValues = new HashMap<Attribute, List<Object>>();
Field[] fields = m.getIdAttribute().getBindableJavaType().getDeclaredFields();
EmbeddableType embeddable = metaModel.embeddable(m.getIdAttribute().getBindableJavaType());
StringBuilder compositeKey = new StringBuilder();
for (Field field : fields)
{
if (!ReflectUtils.isTransientOrStatic(field))
{
AbstractAttribute attrib = (AbstractAttribute) embeddable.getAttribute(field.getName());
Object obj = PropertyAccessorHelper.getObject(value, field);
compositeKey.append(
PropertyAccessorHelper.fromSourceToTargetClass(String.class,
attrib.getBindableJavaType(), obj)).append("\001");
}
}
compositeKey.delete(compositeKey.lastIndexOf("\001"), compositeKey.length());
value = compositeKey.toString();
}
else
{
fieldClazz = f.getType();
}
}
else
{
StringTokenizer tokenizer = new StringTokenizer(jpaFieldName, ".");
String embeddedFieldName = null;
if (tokenizer.countTokens() > 1)
{
embeddedFieldName = tokenizer.nextToken();
String fieldName = tokenizer.nextToken();
Attribute embeddableAttribute = entity.getAttribute(embeddedFieldName);
EmbeddableType embeddableType = metaModel.embeddable(embeddableAttribute.getJavaType());
Attribute embeddedAttribute = embeddableType.getAttribute(fieldName);
jpaFieldName = ((AbstractAttribute) embeddedAttribute).getJPAColumnName();
fieldClazz = ((AbstractAttribute) embeddedAttribute).getBindableJavaType();
}
else
{
String discriminatorColumn = ((AbstractManagedType) entity).getDiscriminatorColumn();
if (!jpaFieldName.equals(discriminatorColumn))
{
String fieldName = m.getFieldName(jpaFieldName);
Attribute col = entity.getAttribute(fieldName);
fieldClazz = ((AbstractAttribute) col).getBindableJavaType();
}
}
}
if (fieldClazz != null)
{
return HBaseUtils.getBytes(value, fieldClazz);
}
else
{
// Treat default as UTF8-Type. { in case of discriminator column}
return HBaseUtils.getBytes(value, String.class);
}
} | java | {
"resource": ""
} |
q164433 | KunderaCoreUtils.getExternalProperties | train | public static Map<String, Object> getExternalProperties(String pu, Map<String, Object> externalProperties,
String... persistenceUnits)
{
Map<String, Object> puProperty;
if (persistenceUnits != null && persistenceUnits.length > 1 && externalProperties != null)
{
puProperty = (Map<String, Object>) externalProperties.get(pu);
// if property found then return it, if it is null by pass it, else
// throw invalidConfiguration.
if (puProperty != null)
{
return fetchPropertyMap(puProperty);
}
return null;
}
return externalProperties;
} | java | {
"resource": ""
} |
q164434 | KunderaCoreUtils.prepareCompositeKey | train | public static String prepareCompositeKey(final EntityMetadata m, final Object compositeKey)
{
Field[] fields = m.getIdAttribute().getBindableJavaType().getDeclaredFields();
StringBuilder stringBuilder = new StringBuilder();
for (Field f : fields)
{
if (!ReflectUtils.isTransientOrStatic(f))
{
try
{
String fieldValue = PropertyAccessorHelper.getString(compositeKey, f);
// what if field value is null????
stringBuilder.append(fieldValue);
stringBuilder.append(COMPOSITE_KEY_SEPERATOR);
}
catch (IllegalArgumentException e)
{
logger.error("Error during prepare composite key, Caused by {}.", e);
throw new PersistenceException(e);
}
}
}
if (stringBuilder.length() > 0)
{
stringBuilder.deleteCharAt(stringBuilder.lastIndexOf(COMPOSITE_KEY_SEPERATOR));
}
return stringBuilder.toString();
} | java | {
"resource": ""
} |
q164435 | KunderaCoreUtils.prepareCompositeKey | train | public static String prepareCompositeKey(final SingularAttribute attribute, final MetamodelImpl metaModel,
final Object compositeKey)
{
Field[] fields = attribute.getBindableJavaType().getDeclaredFields();
EmbeddableType embeddable = metaModel.embeddable(attribute.getBindableJavaType());
StringBuilder stringBuilder = new StringBuilder();
try
{
for (Field f : fields)
{
if (!ReflectUtils.isTransientOrStatic(f))
{
if (metaModel.isEmbeddable(((AbstractAttribute) embeddable.getAttribute(f.getName()))
.getBindableJavaType()))
{
f.setAccessible(true);
stringBuilder.append(
prepareCompositeKey((SingularAttribute) embeddable.getAttribute(f.getName()),
metaModel, f.get(compositeKey))).append(LUCENE_COMPOSITE_KEY_SEPERATOR);
}
else
{
String fieldValue = PropertyAccessorHelper.getString(compositeKey, f);
fieldValue = fieldValue.replaceAll("[^a-zA-Z0-9]", "_");
stringBuilder.append(fieldValue);
stringBuilder.append(LUCENE_COMPOSITE_KEY_SEPERATOR);
}
}
}
}
catch (IllegalAccessException e)
{
logger.error(e.getMessage());
}
catch (IllegalArgumentException e)
{
logger.error("Error during prepare composite key, Caused by {}.", e);
throw new PersistenceException(e);
}
if (stringBuilder.length() > 0)
{
stringBuilder.deleteCharAt(stringBuilder.lastIndexOf(LUCENE_COMPOSITE_KEY_SEPERATOR));
}
return stringBuilder.toString();
} | java | {
"resource": ""
} |
q164436 | KunderaCoreUtils.resolvePath | train | public static String resolvePath(String input)
{
if (null == input)
{
return input;
}
// matching for 2 groups match ${VAR_NAME} or $VAR_NAME
Pattern pathPattern = Pattern.compile("\\$\\{(.+?)\\}");
Matcher matcherPattern = pathPattern.matcher(input); // get a matcher
// object
StringBuffer sb = new StringBuffer();
EnvironmentConfiguration config = new EnvironmentConfiguration();
SystemConfiguration sysConfig = new SystemConfiguration();
while (matcherPattern.find())
{
String confVarName = matcherPattern.group(1) != null ? matcherPattern.group(1) : matcherPattern.group(2);
String envConfVarValue = config.getString(confVarName);
String sysVarValue = sysConfig.getString(confVarName);
if (envConfVarValue != null)
{
matcherPattern.appendReplacement(sb, envConfVarValue);
}
else if (sysVarValue != null)
{
matcherPattern.appendReplacement(sb, sysVarValue);
}
else
{
matcherPattern.appendReplacement(sb, "");
}
}
matcherPattern.appendTail(sb);
return sb.toString();
} | java | {
"resource": ""
} |
q164437 | KunderaCoreUtils.getLuceneQueryFromJPAQuery | train | public static String getLuceneQueryFromJPAQuery(final KunderaQuery kunderaQuery,
final KunderaMetadata kunderaMetadata)
{
LuceneQueryBuilder queryBuilder = new LuceneQueryBuilder();
EntityMetadata metadata = kunderaQuery.getEntityMetadata();
MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
metadata.getPersistenceUnit());
Class valueClazz = null;
EntityType entity = metaModel.entity(metadata.getEntityClazz());
boolean partitionKeyCheck = true;
for (Object object : kunderaQuery.getFilterClauseQueue())
{
if (object instanceof FilterClause)
{
FilterClause filter = (FilterClause) object;
String property = filter.getProperty();
String condition = filter.getCondition();
String valueAsString = filter.getValue().get(0).toString();
String fieldName = metadata.getFieldName(property);
boolean isEmbeddedId = metaModel.isEmbeddable(metadata.getIdAttribute().getBindableJavaType());
String idColumn = ((AbstractAttribute) metadata.getIdAttribute()).getJPAColumnName();
valueClazz = getValueType(entity, fieldName);
if (isEmbeddedId)
{
if (idColumn.equals(property))
{
valueAsString = prepareCompositeKey(metadata.getIdAttribute(), metaModel, filter.getValue()
.get(0));
queryBuilder.appendIndexName(metadata.getIndexName()).appendPropertyName(idColumn)
.buildQuery(condition, valueAsString, valueClazz);
}
else
{
valueClazz = metadata.getIdAttribute().getBindableJavaType();
if (property.lastIndexOf('.') != property.indexOf('.') && partitionKeyCheck)
{
isCompletePartitionKeyPresentInQuery(kunderaQuery.getFilterClauseQueue(), metaModel,
metadata);
partitionKeyCheck = false;
}
if (metaModel.isEmbeddable(filter.getValue().get(0).getClass()))
{
prepareLuceneQueryForPartitionKey(queryBuilder, filter.getValue().get(0), metaModel,
metadata.getIndexName(), valueClazz);
}
else
{
property = property.substring(property.lastIndexOf(".") + 1);
queryBuilder.appendIndexName(metadata.getIndexName())
.appendPropertyName(getPropertyName(metadata, property, kunderaMetadata))
.buildQuery(condition, valueAsString, valueClazz);
}
}
}
else
{
queryBuilder.appendIndexName(metadata.getIndexName())
.appendPropertyName(getPropertyName(metadata, property, kunderaMetadata))
.buildQuery(condition, valueAsString, valueClazz);
}
}
else
{
queryBuilder.buildQuery(object.toString(), object.toString(), String.class);
}
}
queryBuilder.appendEntityName(kunderaQuery.getEntityClass().getCanonicalName().toLowerCase());
return queryBuilder.getQuery();
} | java | {
"resource": ""
} |
q164438 | KunderaCoreUtils.isCompletePartitionKeyPresentInQuery | train | private static void isCompletePartitionKeyPresentInQuery(Queue filterQueue, MetamodelImpl metaModel,
EntityMetadata metadata)
{
Set<String> partitionKeyFields = new HashSet<String>();
populateEmbeddedIdFields(metaModel.embeddable(metadata.getIdAttribute().getBindableJavaType()).getAttributes(),
metaModel, partitionKeyFields);
Set<String> queryAttributes = new HashSet<String>();
for (Object object : filterQueue)
{
if (object instanceof FilterClause)
{
FilterClause filter = (FilterClause) object;
String property = filter.getProperty();
String filterAttr[] = property.split("\\.");
for (String s : filterAttr)
{
queryAttributes.add(s);
}
}
}
if (!queryAttributes.containsAll(partitionKeyFields))
{
throw new QueryHandlerException("Incomplete partition key fields in query");
}
} | java | {
"resource": ""
} |
q164439 | KunderaCoreUtils.populateEmbeddedIdFields | train | private static void populateEmbeddedIdFields(Set<Attribute> embeddedAttributes, MetamodelImpl metaModel,
Set<String> embeddedIdFields)
{
for (Attribute attribute : embeddedAttributes)
{
if (!ReflectUtils.isTransientOrStatic((Field) attribute.getJavaMember()))
{
if (metaModel.isEmbeddable(attribute.getJavaType()))
{
EmbeddableType embeddable = metaModel.embeddable(attribute.getJavaType());
populateEmbeddedIdFieldsUtil(embeddable.getAttributes(), metaModel, embeddedIdFields);
}
}
}
} | java | {
"resource": ""
} |
q164440 | KunderaCoreUtils.getJPAColumnName | train | public static String getJPAColumnName(String field, EntityMetadata entityMetadata, MetamodelImpl metaModel)
{
if (field.indexOf('.') > 0)
{
return ((AbstractAttribute) metaModel.entity(entityMetadata.getEntityClazz()).getAttribute(
field.substring(field.indexOf('.') + 1,
field.indexOf(')') > 0 ? field.indexOf(')') : field.length()))).getJPAColumnName();
}
else
{
return ((AbstractAttribute) entityMetadata.getIdAttribute()).getJPAColumnName();
}
} | java | {
"resource": ""
} |
q164441 | KuduDBDataHandler.addToRow | train | public static void addToRow(PartialRow row, String jpaColumnName, Object value, Type type)
{
if (value == null)
{
row.setNull(jpaColumnName);
}
else
{
switch (type)
{
case BINARY:
row.addBinary(jpaColumnName, (byte[]) value);
break;
case BOOL:
row.addBoolean(jpaColumnName, (Boolean) value);
break;
case DOUBLE:
row.addDouble(jpaColumnName, (Double) value);
break;
case FLOAT:
row.addFloat(jpaColumnName, (Float) value);
break;
case INT16:
row.addShort(jpaColumnName, (Short) value);
break;
case INT32:
row.addInt(jpaColumnName, (Integer) value);
break;
case INT64:
row.addLong(jpaColumnName, (Long) value);
break;
case INT8:
row.addByte(jpaColumnName, (Byte) value);
break;
case STRING:
row.addString(jpaColumnName, (String) value);
break;
case UNIXTIME_MICROS:
default:
logger.error(type + " type is not supported by Kudu");
throw new KunderaException(type + " type is not supported by Kudu");
}
}
} | java | {
"resource": ""
} |
q164442 | KuduDBDataHandler.getPredicate | train | public static KuduPredicate getPredicate(ColumnSchema column, KuduPredicate.ComparisonOp operator, Type type,
Object key)
{
switch (type)
{
case BINARY:
return KuduPredicate.newComparisonPredicate(column, operator, (byte[]) key);
case BOOL:
return KuduPredicate.newComparisonPredicate(column, operator, (Boolean) key);
case DOUBLE:
return KuduPredicate.newComparisonPredicate(column, operator, (Double) key);
case FLOAT:
return KuduPredicate.newComparisonPredicate(column, operator, (Float) key);
case INT16:
return KuduPredicate.newComparisonPredicate(column, operator, (Short) key);
case INT32:
return KuduPredicate.newComparisonPredicate(column, operator, (Integer) key);
case INT64:
return KuduPredicate.newComparisonPredicate(column, operator, (Long) key);
case INT8:
return KuduPredicate.newComparisonPredicate(column, operator, (Byte) key);
case STRING:
return KuduPredicate.newComparisonPredicate(column, operator, (String) key);
case UNIXTIME_MICROS:
default:
logger.error(type + " type is not supported by Kudu");
throw new KunderaException(type + " type is not supported by Kudu");
}
} | java | {
"resource": ""
} |
q164443 | KuduDBDataHandler.getEqualComparisonPredicate | train | public static KuduPredicate getEqualComparisonPredicate(ColumnSchema column, Type type, Object key)
{
return getPredicate(column, KuduPredicate.ComparisonOp.EQUAL, type, key);
} | java | {
"resource": ""
} |
q164444 | KuduDBDataHandler.hasColumn | train | public static boolean hasColumn(Schema schema, String columnName)
{
try
{
schema.getColumn(columnName);
return true;
}
catch (IllegalArgumentException e)
{
return false;
}
} | java | {
"resource": ""
} |
q164445 | EntityFieldAnnotationRule.onSuperClass | train | private void onSuperClass(Class<?> clazz, List<Field> keys)
{
Class<?> superClass = clazz.getSuperclass();
if (superClass != null
&& (superClass.isAnnotationPresent(MappedSuperclass.class) || superClass
.isAnnotationPresent(Entity.class)))
{
while (superClass != null
&& (superClass.isAnnotationPresent(MappedSuperclass.class) || superClass
.isAnnotationPresent(Entity.class)))
{
for (Field field : superClass.getDeclaredFields())
{
// if (checkValidField(field))
// {
onIdField(field, superClass);
if (field.isAnnotationPresent(Id.class))
{
keys.add(field);
// validate @GeneratedValue annotation if given
if (field.isAnnotationPresent(GeneratedValue.class))
{
validateGeneratedValueAnnotation(superClass, field);
}
}
else if (field.isAnnotationPresent(EmbeddedId.class))
{
keys.add(field);
}
// }
}
if (keys.size() > 0)
{
onEntityKey(keys, superClass);
break;
}
superClass = superClass.getSuperclass();
}
}
onEntityKey(keys, clazz);
} | java | {
"resource": ""
} |
q164446 | EntityFieldAnnotationRule.validateGeneratedValueAnnotation | train | private void validateGeneratedValueAnnotation(final Class<?> clazz, Field field)
{
Table table = clazz.getAnnotation(Table.class);
// Still we need to validate for this after post metadata
// population.
if (table != null)
{
String schemaName = table.schema();
if (schemaName != null && schemaName.indexOf('@') > 0)
{
schemaName = schemaName.substring(0, schemaName.indexOf('@'));
GeneratedValue generatedValue = field.getAnnotation(GeneratedValue.class);
if (generatedValue != null && generatedValue.generator() != null
&& !generatedValue.generator().isEmpty())
{
if (!(field.isAnnotationPresent(TableGenerator.class)
|| field.isAnnotationPresent(SequenceGenerator.class)
|| clazz.isAnnotationPresent(TableGenerator.class) || clazz
.isAnnotationPresent(SequenceGenerator.class)))
{
throw new IllegalArgumentException("Unknown Id.generator: " + generatedValue.generator());
}
else
{
checkForGenerator(clazz, field, generatedValue, schemaName);
}
}
}
}
} | java | {
"resource": ""
} |
q164447 | EntityFieldAnnotationRule.checkForGenerator | train | private void checkForGenerator(final Class<?> clazz, Field field, GeneratedValue generatedValue, String schemaName)
{
TableGenerator tableGenerator = field.getAnnotation(TableGenerator.class);
SequenceGenerator sequenceGenerator = field.getAnnotation(SequenceGenerator.class);
if (tableGenerator == null || !tableGenerator.name().equals(generatedValue.generator()))
{
tableGenerator = clazz.getAnnotation(TableGenerator.class);
}
if (sequenceGenerator == null || !sequenceGenerator.name().equals(generatedValue.generator()))
{
sequenceGenerator = clazz.getAnnotation(SequenceGenerator.class);
}
if ((tableGenerator == null && sequenceGenerator == null)
|| (tableGenerator != null && !tableGenerator.name().equals(generatedValue.generator()))
|| (sequenceGenerator != null && !sequenceGenerator.name().equals(generatedValue.generator())))
{
throw new RuleValidationException("Unknown Id.generator: " + generatedValue.generator());
}
else if ((tableGenerator != null && !tableGenerator.schema().isEmpty() && !tableGenerator.schema().equals(
schemaName))
|| (sequenceGenerator != null && !sequenceGenerator.schema().isEmpty() && !sequenceGenerator.schema()
.equals(schemaName)))
{
throw new RuleValidationException("Generator " + generatedValue.generator() + " in entity : "
+ clazz.getName() + " has different schema name ,it should be same as entity have");
}
} | java | {
"resource": ""
} |
q164448 | CassandraClientProperties.setTTLPerRequest | train | private void setTTLPerRequest(Object value)
{
if (value instanceof String)
{
if (Boolean.valueOf((String) value).booleanValue())
{
this.cassandraClientBase.setTtlPerSession(false);
}
this.cassandraClientBase.setTtlPerRequest(Boolean.valueOf((String) value));
}
else if (value instanceof Boolean)
{
if (((Boolean) value).booleanValue())
{
this.cassandraClientBase.setTtlPerSession(false);
}
this.cassandraClientBase.setTtlPerRequest((Boolean) value);
}
} | java | {
"resource": ""
} |
q164449 | CassandraClientProperties.setConsistencylevel | train | private void setConsistencylevel(Object value)
{
if (value instanceof String)
{
this.cassandraClientBase.setConsistencyLevel(ConsistencyLevel.valueOf((String) value));
}
else if (value instanceof ConsistencyLevel)
{
this.cassandraClientBase.setConsistencyLevel((ConsistencyLevel) value);
}
} | java | {
"resource": ""
} |
q164450 | ThriftDataHandler.populateEntityFromSlice | train | private Object populateEntityFromSlice(EntityMetadata m, List<String> relationNames, boolean isWrapReq, Object e,
Map<ByteBuffer, List<ColumnOrSuperColumn>> columnOrSuperColumnsFromRow) throws CharacterCodingException
{
ThriftDataResultHelper dataGenerator = new ThriftDataResultHelper();
for (ByteBuffer key : columnOrSuperColumnsFromRow.keySet())
{
Object id = PropertyAccessorHelper.getObject(m.getIdAttribute().getJavaType(), key.array());
ThriftRow tr = new ThriftRow();
tr.setColumnFamilyName(m.getTableName());
tr.setId(id);
tr = dataGenerator.translateToThriftRow(columnOrSuperColumnsFromRow, m.isCounterColumnType(), m.getType(),
tr);
e = populateEntity(tr, m, e, relationNames, isWrapReq);
}
return e;
} | java | {
"resource": ""
} |
q164451 | OracleNoSQLValidationClassMapper.getValidType | train | public static String getValidType(String type)
{
return (validationClassMapper.get(type) == null) ? "binary" : validationClassMapper.get(type);
} | java | {
"resource": ""
} |
q164452 | OracleNoSQLValidationClassMapper.getValidIdType | train | public static String getValidIdType(String type)
{
if(validationClassMapperforId.get(type) == null){
throw new KunderaException("ID of type: "+type+" is not supported for Kundera Oracle NOSQL.");
}
return validationClassMapperforId.get(type);
} | java | {
"resource": ""
} |
q164453 | KunderaQueryUtils.getWhereClause | train | public static WhereClause getWhereClause(JPQLExpression jpqlExpression)
{
WhereClause whereClause = null;
if (hasWhereClause(jpqlExpression))
{
if (isSelectStatement(jpqlExpression))
{
whereClause = (WhereClause) ((SelectStatement) jpqlExpression.getQueryStatement()).getWhereClause();
}
else if (isUpdateStatement(jpqlExpression))
{
whereClause = (WhereClause) ((UpdateStatement) jpqlExpression.getQueryStatement()).getWhereClause();
}
if (isDeleteStatement(jpqlExpression))
{
whereClause = (WhereClause) ((DeleteStatement) jpqlExpression.getQueryStatement()).getWhereClause();
}
}
return whereClause;
} | java | {
"resource": ""
} |
q164454 | KunderaQueryUtils.getOrderByClause | train | public static OrderByClause getOrderByClause(JPQLExpression jpqlExpression)
{
OrderByClause orderByClause = null;
if (hasOrderBy(jpqlExpression))
{
orderByClause = (OrderByClause) ((SelectStatement) jpqlExpression.getQueryStatement()).getOrderByClause();
}
return orderByClause;
} | java | {
"resource": ""
} |
q164455 | KunderaQueryUtils.hasWhereClause | train | public static boolean hasWhereClause(JPQLExpression jpqlExpression)
{
if (isSelectStatement(jpqlExpression))
{
return ((SelectStatement) jpqlExpression.getQueryStatement()).hasWhereClause();
}
else if (isUpdateStatement(jpqlExpression))
{
return ((UpdateStatement) jpqlExpression.getQueryStatement()).hasWhereClause();
}
if (isDeleteStatement(jpqlExpression))
{
return ((DeleteStatement) jpqlExpression.getQueryStatement()).hasWhereClause();
}
return false;
} | java | {
"resource": ""
} |
q164456 | KunderaQueryUtils.hasGroupBy | train | public static boolean hasGroupBy(JPQLExpression jpqlExpression)
{
if (isSelectStatement(jpqlExpression))
{
return ((SelectStatement) jpqlExpression.getQueryStatement()).hasGroupByClause();
}
return false;
} | java | {
"resource": ""
} |
q164457 | KunderaQueryUtils.hasHaving | train | public static boolean hasHaving(JPQLExpression jpqlExpression)
{
if (isSelectStatement(jpqlExpression))
{
return ((SelectStatement) jpqlExpression.getQueryStatement()).hasHavingClause();
}
return false;
} | java | {
"resource": ""
} |
q164458 | KunderaQueryUtils.hasOrderBy | train | public static boolean hasOrderBy(JPQLExpression jpqlExpression)
{
if (isSelectStatement(jpqlExpression))
{
return ((SelectStatement) jpqlExpression.getQueryStatement()).hasOrderByClause();
}
return false;
} | java | {
"resource": ""
} |
q164459 | KunderaQueryUtils.addToOutputColumns | train | private static void addToOutputColumns(Expression selectExpression, EntityMetadata m,
List<Map<String, Object>> columnsToOutput, KunderaMetadata kunderaMetadata)
{
Map<String, Object> map = setFieldClazzAndColumnFamily(selectExpression, m, kunderaMetadata);
columnsToOutput.add(map);
} | java | {
"resource": ""
} |
q164460 | KunderaQueryUtils.readSelectClause | train | public static List<Map<String, Object>> readSelectClause(Expression selectExpression, EntityMetadata m,
Boolean useLuceneOrES, KunderaMetadata kunderaMetadata)
{
List<Map<String, Object>> columnsToOutput = new ArrayList<Map<String, Object>>();
if (StateFieldPathExpression.class.isAssignableFrom(selectExpression.getClass()))
{
Expression sfpExp = selectExpression;
addToOutputColumns(selectExpression, m, columnsToOutput, kunderaMetadata);
}
else if (CollectionExpression.class.isAssignableFrom(selectExpression.getClass()))
{
CollectionExpression collExp = (CollectionExpression) selectExpression;
ListIterator<Expression> itr = collExp.children().iterator();
while (itr.hasNext())
{
Expression exp = itr.next();
if (StateFieldPathExpression.class.isAssignableFrom(exp.getClass()))
{
addToOutputColumns(exp, m, columnsToOutput, kunderaMetadata);
}
}
}
return columnsToOutput;
} | java | {
"resource": ""
} |
q164461 | KunderaQueryUtils.onRegExpression | train | public static Map<String, Object> onRegExpression(Expression expression, EntityMetadata m,
KunderaMetadata kunderaMetadata, KunderaQuery kunderaQuery)
{
RegexpExpression regExp = (RegexpExpression) expression;
Expression sfpExp = regExp.getStringExpression();
Map<String, Object> map = KunderaQueryUtils.setFieldClazzAndColumnFamily(sfpExp, m, kunderaMetadata);
kunderaQuery.addFilterClause(
(String) map.get(Constants.COL_NAME), regExp.getActualRegexpIdentifier().toUpperCase(),
regExp.getPatternValue().toActualText(), (String) map.get(Constants.FIELD_NAME),
(Boolean) map.get(Constants.IGNORE_CASE));
return map;
} | java | {
"resource": ""
} |
q164462 | KunderaQueryUtils.onLogicalExpression | train | public static void onLogicalExpression(Expression expression, EntityMetadata m, KunderaMetadata kunderaMetadata,
KunderaQuery kunderaQuery)
{
if (expression instanceof OrExpression)
{
kunderaQuery.addFilterClause("(");
}
traverse(((LogicalExpression) expression).getLeftExpression(), m, kunderaMetadata, kunderaQuery, false);
if (expression instanceof OrExpression)
{
kunderaQuery.addFilterClause(")");
}
kunderaQuery.addFilterClause(((LogicalExpression) expression).getIdentifier());
if (expression instanceof OrExpression)
{
kunderaQuery.addFilterClause("(");
}
traverse(((LogicalExpression) expression).getRightExpression(), m, kunderaMetadata, kunderaQuery, false);
if (expression instanceof OrExpression)
{
kunderaQuery.addFilterClause(")");
}
} | java | {
"resource": ""
} |
q164463 | KunderaQueryUtils.onInExpression | train | public static Map<String, Object> onInExpression(Expression expression, EntityMetadata m,
KunderaMetadata kunderaMetadata, KunderaQuery kunderaQuery)
{
InExpression inExp = (InExpression) expression;
Expression sfpExp = inExp.getExpression();
Map<String, Object> map = KunderaQueryUtils.setFieldClazzAndColumnFamily(sfpExp, m, kunderaMetadata);
kunderaQuery.addFilterClause(
(String) map.get(Constants.COL_NAME), inExp.getIdentifier(), inExp.getInItems(),
(String) map.get(Constants.FIELD_NAME), (Boolean) map.get(Constants.IGNORE_CASE));
return map;
} | java | {
"resource": ""
} |
q164464 | KunderaQueryUtils.onComparisonExpression | train | public static Map<String, Object> onComparisonExpression(Expression expression, EntityMetadata m,
KunderaMetadata kunderaMetadata, KunderaQuery kunderaQuery)
{
ComparisonExpression compExp = (ComparisonExpression) expression;
String condition = compExp.getIdentifier();
Expression sfpExp = compExp.getLeftExpression();
Map<String, Object> map = KunderaQueryUtils.setFieldClazzAndColumnFamily(sfpExp, m, kunderaMetadata);
Object value = KunderaQueryUtils.getValue(compExp.getRightExpression(), (Class) map.get(Constants.FIELD_CLAZZ),
kunderaQuery);
kunderaQuery.addFilterClause(
(String) map.get(Constants.COL_NAME), condition, value,
(String) map.get(Constants.FIELD_NAME), (Boolean) map.get(Constants.IGNORE_CASE));
return map;
} | java | {
"resource": ""
} |
q164465 | KunderaQueryUtils.onNullComparisonExpression | train | public static Map<String, Object> onNullComparisonExpression(Expression expression, EntityMetadata m,
KunderaMetadata kunderaMetadata, KunderaQuery kunderaQuery)
{
NullComparisonExpression compExp = (NullComparisonExpression) expression;
String condition = compExp.getIdentifier();
Expression sfpExp = compExp.getExpression();
Map<String, Object> map = KunderaQueryUtils.setFieldClazzAndColumnFamily(sfpExp, m, kunderaMetadata);
kunderaQuery.addFilterClause(
(String) map.get(Constants.COL_NAME), condition, null,
(String) map.get(Constants.FIELD_NAME), (Boolean) map.get(Constants.IGNORE_CASE));
return map;
} | java | {
"resource": ""
} |
q164466 | KunderaQueryUtils.getOrderByItems | train | public static List<OrderByItem> getOrderByItems(JPQLExpression jpqlExpression)
{
List<OrderByItem> orderList = new LinkedList<>();
if (hasOrderBy(jpqlExpression))
{
Expression orderByItems = getOrderByClause(jpqlExpression).getOrderByItems();
if (orderByItems instanceof CollectionExpression)
{
ListIterator<Expression> iterator = orderByItems.children().iterator();
while (iterator.hasNext())
{
OrderByItem orderByItem = (OrderByItem) iterator.next();
orderList.add(orderByItem);
}
}
else
{
orderList.add((OrderByItem) orderByItems);
}
}
return orderList;
} | java | {
"resource": ""
} |
q164467 | CassandraUtilities.appendColumns | train | public static StringBuilder appendColumns(StringBuilder builder, List<String> columns, String selectQuery,
CQLTranslator translator)
{
if (columns != null)
{
for (String column : columns)
{
translator.appendColumnName(builder, column);
builder.append(",");
}
}
if (builder.lastIndexOf(",") != -1)
{
builder.deleteCharAt(builder.length() - 1);
selectQuery = StringUtils.replace(selectQuery, CQLTranslator.COLUMNS, builder.toString());
}
builder = new StringBuilder(selectQuery);
return builder;
} | java | {
"resource": ""
} |
q164468 | CassandraEntityReader.handleFindByRange | train | public List handleFindByRange(EntityMetadata m, Client client, List result,
Map<Boolean, List<IndexClause>> ixClause, boolean isRowKeyQuery, List<String> columns, int maxResults)
{
List<IndexExpression> expressions = ixClause.get(isRowKeyQuery).get(0).getExpressions();
if (expressions == null)
{
return null;
}
Map<String, byte[]> rowKeys = getRowKeyValue(expressions,
((AbstractAttribute) m.getIdAttribute()).getJPAColumnName());
byte[] minValue = rowKeys.get(MIN_);
byte[] maxVal = rowKeys.get(MAX_);
try
{
result = ((CassandraClientBase) client).findByRange(minValue, maxVal, m, m.getRelationNames() != null
&& !m.getRelationNames().isEmpty(), m.getRelationNames(), columns, expressions, maxResults);
}
catch (Exception e)
{
log.error("Error while executing find by range, Caused by: ", e);
throw new QueryHandlerException(e);
}
return result;
} | java | {
"resource": ""
} |
q164469 | CassandraEntityReader.readFromIndexTable | train | public List<EnhanceEntity> readFromIndexTable(EntityMetadata m, Client client,
Map<Boolean, List<IndexClause>> indexClauseMap)
{
List<SearchResult> searchResults = new ArrayList<SearchResult>();
List<Object> primaryKeys = new ArrayList<Object>();
String columnFamilyName = m.getTableName() + Constants.INDEX_TABLE_SUFFIX;
searchResults = ((CassandraClientBase) client).searchInInvertedIndex(columnFamilyName, m, indexClauseMap);
Map<String, String> embeddedColumns = new HashMap<String, String>();
for (SearchResult searchResult : searchResults)
{
if (searchResult.getEmbeddedColumnValues() != null)
{
for (String embeddedColVal : searchResult.getEmbeddedColumnValues())
{
if (embeddedColVal != null)
{
StringBuilder strBuilder = new StringBuilder(embeddedColVal);
strBuilder.append("|");
strBuilder.append(searchResult.getPrimaryKey().toString());
embeddedColumns.put(strBuilder.toString(), searchResult.getPrimaryKey().toString());
}
}
}
}
List<EnhanceEntity> enhanceEntityList = new ArrayList<EnhanceEntity>();
if (embeddedColumns != null && !embeddedColumns.isEmpty())
{
enhanceEntityList = client.find(m.getEntityClazz(), embeddedColumns);
}
else
{
for (SearchResult searchResult : searchResults)
{
primaryKeys.add(searchResult.getPrimaryKey());
}
enhanceEntityList = (List<EnhanceEntity>) ((CassandraClientBase) client).find(m.getEntityClazz(),
m.getRelationNames(), true, m, primaryKeys.toArray(new String[] {}));
}
return enhanceEntityList;
} | java | {
"resource": ""
} |
q164470 | CassandraEntityReader.getRowKeyValue | train | Map<String, byte[]> getRowKeyValue(List<IndexExpression> expressions, String primaryKeyName)
{
Map<String, byte[]> rowKeys = new HashMap<String, byte[]>();
List<IndexExpression> rowExpressions = new ArrayList<IndexExpression>();
if (expressions != null)
{
for (IndexExpression e : expressions)
{
if (primaryKeyName.equals(new String(e.getColumn_name())))
{
IndexOperator operator = e.op;
if (operator.equals(IndexOperator.LTE) || operator.equals(IndexOperator.LT))
{
rowKeys.put(MAX_, e.getValue());
rowExpressions.add(e);
}
else if (operator.equals(IndexOperator.GTE) || operator.equals(IndexOperator.GT))
{
rowKeys.put(MIN_, e.getValue());
rowExpressions.add(e);
}
else if (operator.equals(IndexOperator.EQ))
{
rowKeys.put(MAX_, e.getValue());
rowKeys.put(MIN_, e.getValue());
rowExpressions.add(e);
}
}
}
expressions.removeAll(rowExpressions);
}
return rowKeys;
} | java | {
"resource": ""
} |
q164471 | AbstractIdentifiableType.addIdAttribute | train | public void addIdAttribute(SingularAttribute<? super X, ?> idAttribute, boolean isIdClass,
Set<SingularAttribute<? super X, ?>> idClassAttributes)
{
this.idAttribute = idAttribute;
this.isIdClass = isIdClass;
this.idClassAttributes = idClassAttributes;
if (MetadataUtils.onCheckValidationConstraints((Field) idAttribute.getJavaMember()))
{
this.hasValidationConstraints = true;
}
} | java | {
"resource": ""
} |
q164472 | HBaseClient.findByRange | train | public <E> List<E> findByRange(Class<E> entityClass, EntityMetadata metadata, byte[] startRow, byte[] endRow,
String[] columns, Filter f, Queue filterClausequeue)
{
EntityMetadata entityMetadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entityClass);
// columnFamily has a different meaning for HBase, so it won't be used
// here
String tableName = entityMetadata.getSchema();
List results = new ArrayList();
FilterList filter = new FilterList();
if (f != null)
{
filter.addFilter(f);
}
if (isFindKeyOnly(metadata, columns))
{
columns = null;
filter.addFilter(new KeyOnlyFilter());
}
try
{
MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
entityMetadata.getPersistenceUnit());
EntityType entityType = metaModel.entity(entityClass);
List<AbstractManagedType> subManagedType = ((AbstractManagedType) entityType).getSubManagedType();
if (!subManagedType.isEmpty())
{
for (AbstractManagedType subEntity : subManagedType)
{
EntityMetadata subEntityMetadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata,
subEntity.getJavaType());
List found = handler.readDataByRange(tableName, subEntityMetadata.getEntityClazz(),
subEntityMetadata, startRow, endRow, columns, filter);
results.addAll(found);
}
}
else
{
results = handler.readDataByRange(tableName, entityClass, metadata, startRow, endRow, columns, filter);
}
if (showQuery && filterClausequeue.size() > 0)
{
KunderaCoreUtils.printQueryWithFilterClause(filterClausequeue, entityMetadata.getTableName());
}
}
catch (IOException ioex)
{
log.error("Error during find by range, Caused by: .", ioex);
throw new KunderaException(ioex);
}
return results;
} | java | {
"resource": ""
} |
q164473 | HBaseClient.addRecords | train | private void addRecords(HBaseDataWrapper columnWrapper, List<HBaseDataWrapper> embeddableData,
List<HBaseDataWrapper> dataSet)
{
dataSet.add(columnWrapper);
if (!embeddableData.isEmpty())
{
dataSet.addAll(embeddableData);
}
} | java | {
"resource": ""
} |
q164474 | HBaseClient.fetchEntity | train | private List fetchEntity(Class entityClass, Object rowId, EntityMetadata entityMetadata,
List<String> relationNames, String tableName, List results, FilterList filter, Queue filterClausequeue,
String... columns) throws IOException
{
results = new ArrayList();
List<AbstractManagedType> subManagedType = getSubManagedType(entityClass, entityMetadata);
if (!subManagedType.isEmpty())
{
for (AbstractManagedType subEntity : subManagedType)
{
EntityMetadata subEntityMetadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata,
subEntity.getJavaType());
List tempResults = handler.readData(tableName, subEntityMetadata.getEntityClazz(), subEntityMetadata,
rowId, subEntityMetadata.getRelationNames(), filter, columns);
if (tempResults != null && !tempResults.isEmpty())
{
results.addAll(tempResults);
}
}
}
else
{
results = handler.readData(tableName, entityMetadata.getEntityClazz(), entityMetadata, rowId,
relationNames, filter, columns);
}
if (rowId != null)
{
KunderaCoreUtils.printQuery("Fetch data from " + entityMetadata.getTableName() + " for PK " + rowId,
showQuery);
}
else if (showQuery && filterClausequeue.size() > 0)
{
KunderaCoreUtils.printQueryWithFilterClause(filterClausequeue, entityMetadata.getTableName());
}
return results;
} | java | {
"resource": ""
} |
q164475 | HBaseClient.getSubManagedType | train | private List<AbstractManagedType> getSubManagedType(Class entityClass, EntityMetadata entityMetadata)
{
MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
entityMetadata.getPersistenceUnit());
EntityType entityType = metaModel.entity(entityClass);
List<AbstractManagedType> subManagedType = ((AbstractManagedType) entityType).getSubManagedType();
return subManagedType;
} | java | {
"resource": ""
} |
q164476 | ThriftDataResultHelper.translateToThriftRow | train | public ThriftRow translateToThriftRow(Map<ByteBuffer, List<ColumnOrSuperColumn>> coscResultMap,
boolean isCounterType, Type columnFamilyType, ThriftRow row)
{
ColumnFamilyType columnType = ColumnFamilyType.COLUMN;
if (isCounterType)
{
if (columnFamilyType.equals(Type.SUPER_COLUMN_FAMILY))
{
columnType = ColumnFamilyType.COUNTER_SUPER_COLUMN;
}
else
{
columnType = ColumnFamilyType.COUNTER_COLUMN;
}
}
else if (columnFamilyType.equals(Type.SUPER_COLUMN_FAMILY))
{
columnType = ColumnFamilyType.SUPER_COLUMN;
}
transformThriftResultAndAddToList(coscResultMap, columnType, row);
return row;
} | java | {
"resource": ""
} |
q164477 | KuduDBQuery.addInPredicateToBuilder | train | private void addInPredicateToBuilder(KuduScannerBuilder scannerBuilder, ListIterator<Expression> inIter,
Attribute attribute)
{
List<Object> finalVals = new ArrayList<>();
Type type = KuduDBValidationClassMapper.getValidTypeForClass(((Field) attribute.getJavaMember()).getType());
ColumnSchema column = new ColumnSchema.ColumnSchemaBuilder(((AbstractAttribute) attribute).getJPAColumnName(),
type).build();
while (inIter.hasNext())
{
String val = inIter.next().toActualText();
finalVals.add(KuduDBDataHandler.parse(type, val));
}
scannerBuilder.addPredicate(KuduDBDataHandler.getInPredicate(column, finalVals));
} | java | {
"resource": ""
} |
q164478 | KuduDBQuery.addColumnRangePredicateToBuilder | train | private void addColumnRangePredicateToBuilder(Field field, KuduScannerBuilder scannerBuilder, String columnName,
String value, String identifier)
{
Type type = KuduDBValidationClassMapper.getValidTypeForClass(field.getType());
ColumnSchema column = new ColumnSchema.ColumnSchemaBuilder(columnName, type).build();
KuduPredicate predicate;
Object valueObject = KuduDBDataHandler.parse(type, value);
switch (identifier)
{
case ">=":
predicate = KuduDBDataHandler.getPredicate(column, KuduPredicate.ComparisonOp.GREATER_EQUAL, type,
valueObject);
break;
case ">":
predicate = KuduDBDataHandler.getPredicate(column, KuduPredicate.ComparisonOp.GREATER, type, valueObject);
break;
case "<":
predicate = KuduDBDataHandler.getPredicate(column, KuduPredicate.ComparisonOp.LESS, type, valueObject);
break;
case "<=":
predicate = KuduDBDataHandler
.getPredicate(column, KuduPredicate.ComparisonOp.LESS_EQUAL, type, valueObject);
break;
case "=":
predicate = KuduDBDataHandler.getPredicate(column, KuduPredicate.ComparisonOp.EQUAL, type, valueObject);
break;
default:
logger.error("Operation not supported");
throw new KunderaException("Operation not supported");
}
scannerBuilder.addPredicate(predicate);
} | java | {
"resource": ""
} |
q164479 | DSClientUtilities.setIntValue | train | private static Object setIntValue(Field member, Object retVal)
{
if (member != null)
{
if (member.getType().isAssignableFrom(byte.class))
{
retVal = ((Integer) retVal).byteValue();
}
else if (member.getType().isAssignableFrom(short.class))
{
retVal = ((Integer) retVal).shortValue();
}
}
return retVal;
} | java | {
"resource": ""
} |
q164480 | DSClientUtilities.setTextValue | train | private static Object setTextValue(Object entity, Field member, Object retVal)
{
if (member != null && member.getType().isEnum())
{
EnumAccessor accessor = new EnumAccessor();
if (member != null)
{
retVal = accessor.fromString(member.getType(), (String) retVal);
}
}
else if (member != null
&& (member.getType().isAssignableFrom(char.class) || member.getType().isAssignableFrom(Character.class)))
{
retVal = new CharAccessor().fromString(member.getType(), (String) retVal);
}
return retVal;
} | java | {
"resource": ""
} |
q164481 | CassandraDataHandlerBase.populateEmbeddedObject | train | private Object populateEmbeddedObject(SuperColumn sc, EntityMetadata m) throws Exception
{
Field embeddedCollectionField = null;
Object embeddedObject = null;
String scName = PropertyAccessorFactory.STRING.fromBytes(String.class, sc.getName());
String scNamePrefix = null;
// Get a name->field map for super-columns
Map<String, Field> columnNameToFieldMap = new HashMap<String, Field>();
Map<String, Field> superColumnNameToFieldMap = new HashMap<String, Field>();
MetadataUtils.populateColumnAndSuperColumnMaps(m, columnNameToFieldMap, superColumnNameToFieldMap,
kunderaMetadata);
// If this super column is variable in number (name#sequence format)
if (scName.indexOf(Constants.EMBEDDED_COLUMN_NAME_DELIMITER) != -1)
{
StringTokenizer st = new StringTokenizer(scName, Constants.EMBEDDED_COLUMN_NAME_DELIMITER);
if (st.hasMoreTokens())
{
scNamePrefix = st.nextToken();
}
embeddedCollectionField = superColumnNameToFieldMap.get(scNamePrefix);
Class<?> embeddedClass = PropertyAccessorHelper.getGenericClass(embeddedCollectionField);
// must have a default no-argument constructor
try
{
embeddedClass.getConstructor();
}
catch (NoSuchMethodException nsme)
{
throw new PersistenceException(embeddedClass.getName()
+ " is @Embeddable and must have a default no-argument constructor.");
}
embeddedObject = embeddedClass.newInstance();
for (Column column : sc.getColumns())
{
String name = PropertyAccessorFactory.STRING.fromBytes(String.class, column.getName());
byte[] value = column.getValue();
if (value == null)
{
continue;
}
Field columnField = columnNameToFieldMap.get(name);
PropertyAccessorHelper.set(embeddedObject, columnField, value);
}
}
else
{
Field superColumnField = superColumnNameToFieldMap.get(scName);
Class superColumnClass = superColumnField.getType();
embeddedObject = superColumnClass.newInstance();
for (Column column : sc.getColumns())
{
String name = PropertyAccessorFactory.STRING.fromBytes(String.class, column.getName());
byte[] value = column.getValue();
if (value == null)
{
continue;
}
// set value of the field in the bean
Field columnField = columnNameToFieldMap.get(name);
PropertyAccessorHelper.set(embeddedObject, columnField, value);
}
}
return embeddedObject;
} | java | {
"resource": ""
} |
q164482 | CassandraDataHandlerBase.getThriftRow | train | private ThriftRow getThriftRow(Object id, String columnFamily, Map<String, ThriftRow> thriftRows)
{
ThriftRow tr = thriftRows.get(columnFamily);
if (tr == null)
{
tr = new ThriftRow();
tr.setColumnFamilyName(columnFamily); // column-family name
tr.setId(id); // Id
thriftRows.put(columnFamily, tr);
}
return tr;
} | java | {
"resource": ""
} |
q164483 | CassandraDataHandlerBase.toIndexThriftRow | train | public List<ThriftRow> toIndexThriftRow(Object e, EntityMetadata m, String columnFamily)
{
List<ThriftRow> indexThriftRows = new ArrayList<ThriftRow>();
byte[] rowKey = getThriftColumnValue(e, m.getIdAttribute());
MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
m.getPersistenceUnit());
// Add thrift rows for embeddables
Map<String, EmbeddableType> embeddables = metaModel.getEmbeddables(m.getEntityClazz());
EntityType entityType = metaModel.entity(m.getEntityClazz());
for (String embeddedFieldName : embeddables.keySet())
{
EmbeddableType embeddedColumn = embeddables.get(embeddedFieldName);
// Index embeddable only when specified by user
Field embeddedField = (Field) entityType.getAttribute(embeddedFieldName).getJavaMember();
if (!MetadataUtils.isEmbeddedAtributeIndexable(embeddedField))
{
continue;
}
Object embeddedObject = PropertyAccessorHelper.getObject(e,
(Field) entityType.getAttribute(embeddedFieldName).getJavaMember());
if (embeddedObject == null)
{
continue;
}
if (embeddedObject instanceof Collection)
{
ElementCollectionCacheManager ecCacheHandler = ElementCollectionCacheManager.getInstance();
for (Object obj : (Collection) embeddedObject)
{
for (Object column : embeddedColumn.getAttributes())
{
Attribute columnAttribute = (Attribute) column;
String columnName = columnAttribute.getName();
if (!MetadataUtils.isColumnInEmbeddableIndexable(embeddedField, columnName))
{
continue;
}
// Column Value
String id = (String) CassandraDataTranslator.decompose(
((AbstractAttribute) m.getIdAttribute()).getBindableJavaType(), rowKey, false);
String superColumnName = ecCacheHandler.getElementCollectionObjectName(id, obj);
ThriftRow tr = constructIndexTableThriftRow(columnFamily, embeddedFieldName, obj,
columnAttribute, rowKey, superColumnName);
if (tr != null)
{
indexThriftRows.add(tr);
}
}
}
}
else
{
for (Object column : embeddedColumn.getAttributes())
{
Attribute columnAttribute = (Attribute) column;
String columnName = columnAttribute.getName();
Class<?> columnClass = ((AbstractAttribute) columnAttribute).getBindableJavaType();
if (!MetadataUtils.isColumnInEmbeddableIndexable(embeddedField, columnName)
|| columnClass.equals(byte[].class))
{
continue;
}
// No EC Name
ThriftRow tr = constructIndexTableThriftRow(columnFamily, embeddedFieldName, embeddedObject,
(Attribute) column, rowKey, "");
if (tr != null)
{
indexThriftRows.add(tr);
}
}
}
}
return indexThriftRows;
} | java | {
"resource": ""
} |
q164484 | CassandraDataHandlerBase.getForeignKeysFromJoinTable | train | public <E> List<Object> getForeignKeysFromJoinTable(String inverseJoinColumnName, List<Column> columns,
Class columnJavaType)
{
List<Object> foreignKeys = new ArrayList<Object>();
if (columns == null || columns.isEmpty())
{
return foreignKeys;
}
for (Column c : columns)
{
try
{
// Thrift Column name
String thriftColumnName = PropertyAccessorFactory.STRING.fromBytes(String.class, c.getName());
// Thrift Column Value
byte[] thriftColumnValue = c.getValue();
if (null == thriftColumnValue)
{
continue;
}
if (thriftColumnName != null && thriftColumnName.startsWith(inverseJoinColumnName))
{
Object val = PropertyAccessorHelper.getObject(columnJavaType, thriftColumnValue);
foreignKeys.add(val);
}
}
catch (PropertyAccessException e)
{
continue;
}
}
return foreignKeys;
} | java | {
"resource": ""
} |
q164485 | CassandraDataHandlerBase.setId | train | private void setId(EntityMetadata m, Object entity, Object columnValue, boolean isCql3Enabled)
{
if (isCql3Enabled && !m.getType().equals(Type.SUPER_COLUMN_FAMILY))
{
setFieldValueViaCQL(entity, columnValue, m.getIdAttribute());
}
else
{
setFieldValue(entity, columnValue, m.getIdAttribute());
}
} | java | {
"resource": ""
} |
q164486 | CassandraDataHandlerBase.isAggregate | train | private boolean isAggregate(String thriftColumnName)
{
if (thriftColumnName.startsWith(SYS_COUNT) || thriftColumnName.startsWith(SYS_MIN)
|| thriftColumnName.startsWith(SYS_MAX) || thriftColumnName.startsWith(SYS_AVG)
|| thriftColumnName.startsWith(SYS_SUM))
{
return true;
}
else if (thriftColumnName.startsWith(COUNT) || thriftColumnName.startsWith(MIN)
|| thriftColumnName.startsWith(MAX) || thriftColumnName.startsWith(AVG)
|| thriftColumnName.startsWith(SUM))
{
return true;
}
return false;
} | java | {
"resource": ""
} |
q164487 | CassandraDataHandlerBase.composeAndAdd | train | private void composeAndAdd(HashMap entity, CqlMetadata cqlMetadata, Object thriftColumnValue,
String thriftColumnName)
{
byte[] columnName = thriftColumnName.getBytes();
Map<ByteBuffer, String> schemaTypes = this.clientBase.getCqlMetadata().getValue_types();
AbstractType<?> type = null;
try
{
type = TypeParser.parse(schemaTypes.get(ByteBuffer.wrap((byte[]) columnName)));
}
catch (SyntaxException | ConfigurationException e)
{
log.error(e.getMessage());
throw new KunderaException("Error while parsing CQL Type " + e);
}
entity.put(thriftColumnName, type.compose(ByteBuffer.wrap((byte[]) thriftColumnValue)));
} | java | {
"resource": ""
} |
q164488 | CassandraDataHandlerBase.setFieldValueViaCQL | train | private void setFieldValueViaCQL(Object entity, Object thriftColumnValue, Attribute attribute)
{
if (attribute != null)
{
try
{
if (attribute.isCollection())
{
setCollectionValue(entity, thriftColumnValue, attribute);
}
else if (CassandraDataTranslator.isCassandraDataTypeClass(((AbstractAttribute) attribute)
.getBindableJavaType()))
{
PropertyAccessorHelper.set(entity, (Field) attribute.getJavaMember(), CassandraDataTranslator
.decompose(((AbstractAttribute) attribute).getBindableJavaType(), thriftColumnValue, true));
}
else
{
PropertyAccessorHelper.set(entity, (Field) attribute.getJavaMember(), (byte[]) thriftColumnValue);
}
}
catch (PropertyAccessException pae)
{
log.warn("Error while setting field{} value via CQL, Caused by: .", attribute.getName(), pae);
}
}
} | java | {
"resource": ""
} |
q164489 | CassandraDataHandlerBase.setElementCollectionMap | train | private Object setElementCollectionMap(MapType mapType, ByteBuffer thriftColumnValue, Object entity, Field field,
MetamodelImpl metaModel, Class embeddedClass, boolean useNativeProtocol2)
{
Map result = new HashMap();
MapSerializer mapSerializer = mapType.getSerializer();
Map outputCollection = new HashMap();
if (useNativeProtocol2)
{
outputCollection.putAll(mapSerializer.deserializeForNativeProtocol(thriftColumnValue, ProtocolVersion.V2));
}
else
{
outputCollection.putAll((Map) mapSerializer.deserialize(thriftColumnValue));
}
UserType usertype = (UserType) mapType.getValuesType();
for (Object key : outputCollection.keySet())
{
Object embeddedObject = KunderaCoreUtils.createNewInstance(embeddedClass);
Object value = populateEmbeddedRecursive((ByteBuffer) outputCollection.get(key), usertype.allTypes(),
usertype.fieldNames(), embeddedObject, metaModel);
result.put(key, value);
}
PropertyAccessorHelper.set(entity, field, result);
return entity;
} | java | {
"resource": ""
} |
q164490 | CassandraDataHandlerBase.setElementCollectionSet | train | private Object setElementCollectionSet(SetType setType, ByteBuffer thriftColumnValue, Object entity, Field field,
MetamodelImpl metaModel, Class embeddedClass, boolean useNativeProtocol2)
{
SetSerializer setSerializer = setType.getSerializer();
Collection outputCollection = new ArrayList();
if (useNativeProtocol2)
{
outputCollection.addAll((Collection) setSerializer.deserializeForNativeProtocol(thriftColumnValue, ProtocolVersion.V2));
}
else
{
outputCollection.addAll((Collection) setSerializer.deserialize(thriftColumnValue));
}
UserType usertype = (UserType) setType.getElementsType();
Collection result = new HashSet();
Iterator collectionItems = outputCollection.iterator();
while (collectionItems.hasNext())
{
Object embeddedObject = KunderaCoreUtils.createNewInstance(embeddedClass);
Object value = populateEmbeddedRecursive((ByteBuffer) collectionItems.next(), usertype.allTypes(),
usertype.fieldNames(), embeddedObject, metaModel);
result.add(value);
}
PropertyAccessorHelper.set(entity, field, result);
return entity;
} | java | {
"resource": ""
} |
q164491 | CassandraDataHandlerBase.setElementCollectionList | train | private Object setElementCollectionList(ListType listType, ByteBuffer thriftColumnValue, Object entity,
Field field, MetamodelImpl metaModel, Class embeddedClass, boolean useNativeProtocol2)
{
ListSerializer listSerializer = listType.getSerializer();
Collection outputCollection = new ArrayList();
if (useNativeProtocol2)
{
outputCollection.addAll((Collection) listSerializer.deserializeForNativeProtocol(thriftColumnValue, ProtocolVersion.V2));
}
else
{
outputCollection.addAll((Collection) listSerializer.deserialize(thriftColumnValue));
}
UserType usertype = (UserType) listType.getElementsType();
Collection result = new ArrayList();
Iterator collectionItems = outputCollection.iterator();
while (collectionItems.hasNext())
{
Object embeddedObject = KunderaCoreUtils.createNewInstance(embeddedClass);
Object value = populateEmbeddedRecursive((ByteBuffer) collectionItems.next(), usertype.allTypes(),
usertype.fieldNames(), embeddedObject, metaModel);
result.add(value);
}
PropertyAccessorHelper.set(entity, field, result);
return entity;
} | java | {
"resource": ""
} |
q164492 | CassandraDataHandlerBase.getFieldValueViaCQL | train | private Object getFieldValueViaCQL(Object thriftColumnValue, Attribute attribute)
{
PropertyAccessor<?> accessor = PropertyAccessorFactory.getPropertyAccessor((Field) attribute.getJavaMember());
Object objValue;
try
{
if (CassandraDataTranslator.isCassandraDataTypeClass(((AbstractAttribute) attribute).getBindableJavaType()))
{
objValue = CassandraDataTranslator.decompose(((AbstractAttribute) attribute).getBindableJavaType(),
thriftColumnValue, true);
return objValue;
}
else
{
objValue = accessor.fromBytes(((AbstractAttribute) attribute).getBindableJavaType(),
(byte[]) thriftColumnValue);
return objValue;
}
}
catch (PropertyAccessException pae)
{
log.warn("Error while setting field{} value via CQL, Caused by: .", attribute.getName(), pae);
}
return null;
} | java | {
"resource": ""
} |
q164493 | CassandraDataHandlerBase.onColumnOrSuperColumnThriftRow | train | private Collection<ThriftRow> onColumnOrSuperColumnThriftRow(EntityMetadata m, Object e, Object id, long timestamp,
Object columnTTLs)
{
// Iterate through Super columns
Map<String, ThriftRow> thriftRows = new HashMap<String, ThriftRow>();
MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata().getMetamodel(
m.getPersistenceUnit());
EntityType entityType = metaModel.entity(m.getEntityClazz());
Set<Attribute> attributes = entityType.getAttributes();
for (Attribute attribute : attributes)
{
String tableName = ((AbstractAttribute) attribute).getTableName() != null ? ((AbstractAttribute) attribute)
.getTableName() : m.getTableName();
ThriftRow tr = getThriftRow(id, tableName, thriftRows);
if (!attribute.getName().equals(m.getIdAttribute().getName()) && !attribute.isAssociation())
{
Field field = (Field) ((Attribute) attribute).getJavaMember();
byte[] name = ByteBufferUtil.bytes(((AbstractAttribute) attribute).getJPAColumnName()).array();
// if attribute is embeddable.
if (metaModel.isEmbeddable(attribute.isCollection() ? ((PluralAttribute) attribute)
.getBindableJavaType() : attribute.getJavaType()))
{
Map<String, Object> thriftSuperColumns = onEmbeddable(timestamp, tr, m, e, id, attribute);
if (thriftSuperColumns != null)
{
for (String columnFamilyName : thriftSuperColumns.keySet())
{
ThriftRow thriftRow = getThriftRow(id, columnFamilyName, thriftRows);
if (m.isCounterColumnType())
{
thriftRow.addCounterSuperColumn((CounterSuperColumn) thriftSuperColumns
.get(columnFamilyName));
}
else
{
thriftRow.addSuperColumn((SuperColumn) thriftSuperColumns.get(columnFamilyName));
}
}
}
}
else
{
Object value = getColumnValue(m, e, attribute);
if (m.getType().equals(Type.SUPER_COLUMN_FAMILY))
{
prepareSuperColumn(tr, m, value, name, timestamp);
}
else
{
int ttl = getTTLForColumn(columnTTLs, attribute);
prepareColumn(tr, m, value, name, timestamp, ttl);
}
}
}
}
// Add discriminator column.
onDiscriminatorColumn(thriftRows.get(m.getTableName()), timestamp, entityType);
return thriftRows.values();
} | java | {
"resource": ""
} |
q164494 | CassandraDataHandlerBase.getTTLForColumn | train | private int getTTLForColumn(Object columnTTLs, Attribute attribute)
{
Integer ttl = null;
if (columnTTLs != null)
{
if (columnTTLs instanceof Map)
{
ttl = (Integer) (columnTTLs == null ? 0 : ((Map) columnTTLs).get(((AbstractAttribute) attribute)
.getJPAColumnName()));
}
else if (columnTTLs instanceof Integer)
{
ttl = (Integer) columnTTLs;
}
}
return ttl == null ? 0 : ttl;
} | java | {
"resource": ""
} |
q164495 | CassandraDataHandlerBase.getThriftColumnValue | train | protected byte[] getThriftColumnValue(Object e, Attribute attribute)
{
byte[] value = null;
Field field = (Field) ((Attribute) attribute).getJavaMember();
try
{
if (attribute != null && field.get(e) != null)
{
if (CassandraDataTranslator.isCassandraDataTypeClass(((AbstractAttribute) attribute)
.getBindableJavaType()))
{
value = CassandraDataTranslator.compose(((AbstractAttribute) attribute).getBindableJavaType(),
field.get(e), false);
}
else
{
value = PropertyAccessorHelper.get(e, field);
}
}
}
catch (IllegalArgumentException iae)
{
log.error("Error while persisting data, Caused by: .", iae);
throw new IllegalArgumentException(iae);
}
catch (IllegalAccessException iace)
{
log.error("Error while persisting data, Caused by: .", iace);
}
return value;
} | java | {
"resource": ""
} |
q164496 | CassandraDataHandlerBase.prepareSuperColumn | train | private void prepareSuperColumn(ThriftRow tr, EntityMetadata m, Object value, byte[] name, long timestamp)
{
if (value != null)
{
if (m.isCounterColumnType())
{
CounterSuperColumn counterSuper = new CounterSuperColumn();
counterSuper.setName(name);
CounterColumn counterColumn = prepareCounterColumn((String) value, name);
List<CounterColumn> subCounterColumn = new ArrayList<CounterColumn>();
subCounterColumn.add(counterColumn);
counterSuper.setColumns(subCounterColumn);
tr.addCounterSuperColumn(counterSuper);
}
else
{
SuperColumn superCol = new SuperColumn();
superCol.setName(name);
Column column = prepareColumn((byte[]) value, name, timestamp, 0);
List<Column> subColumn = new ArrayList<Column>();
subColumn.add(column);
superCol.setColumns(subColumn);
tr.addSuperColumn(superCol);
}
}
} | java | {
"resource": ""
} |
q164497 | CassandraDataHandlerBase.prepareCounterColumn | train | private CounterColumn prepareCounterColumn(String value, byte[] name)
{
CounterColumn counterColumn = new CounterColumn();
counterColumn.setName(name);
LongAccessor accessor = new LongAccessor();
counterColumn.setValue(accessor.fromString(LongAccessor.class, value));
return counterColumn;
} | java | {
"resource": ""
} |
q164498 | CassandraDataHandlerBase.buildThriftCounterSuperColumn | train | private Map<String, Object> buildThriftCounterSuperColumn(String tableName, String superColumnName,
EmbeddableType superColumn, Object counterSuperColumnObject)
{
Map<String, Object> thriftCounterSuperColumns = new HashMap<String, Object>();
Iterator<Attribute> iter = superColumn.getAttributes().iterator();
List<CounterColumn> thriftColumns = new ArrayList<CounterColumn>();
while (iter.hasNext())
{
Attribute column = iter.next();
Field field = (Field) column.getJavaMember();
String name = ((AbstractAttribute) column).getJPAColumnName();
String value = null;
try
{
value = PropertyAccessorHelper.getString(counterSuperColumnObject, field);
}
catch (PropertyAccessException exp)
{
// This is an entity column to be persisted in a super column
// family. It will be stored as a super column that would
// have just one column with the same name
if (log.isInfoEnabled())
{
log.info(exp.getMessage()
+ ". Possible case of entity column in a super column family. Will be treated as a super column.");
}
value = counterSuperColumnObject.toString();
}
if (null != value)
{
try
{
CounterColumn thriftColumn = new CounterColumn();
thriftColumn.setName(PropertyAccessorFactory.STRING.toBytes(name));
thriftColumn.setValue(Long.parseLong(value));
thriftColumns.add(thriftColumn);
tableName = ((AbstractAttribute) column).getTableName() != null ? ((AbstractAttribute) column)
.getTableName() : tableName;
CounterSuperColumn thriftSuperColumn = (CounterSuperColumn) thriftCounterSuperColumns
.get(tableName);
if (thriftSuperColumn == null)
{
thriftSuperColumn = new CounterSuperColumn();
thriftSuperColumn.setName(PropertyAccessorFactory.STRING.toBytes(superColumnName));
thriftCounterSuperColumns.put(tableName, thriftSuperColumn);
}
thriftSuperColumn.addToColumns(thriftColumn);
}
catch (NumberFormatException nfe)
{
log.error("For counter column arguments should be numeric type, Caused by: .", nfe);
throw new KunderaException(nfe);
}
}
}
return thriftCounterSuperColumns;
} | java | {
"resource": ""
} |
q164499 | OracleNoSQLClient.find | train | private Object find(Class entityClass, Object key, List<String> columnsToSelect)
{
EntityMetadata entityMetadata = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entityClass);
MetamodelImpl metamodel = (MetamodelImpl) KunderaMetadataManager.getMetamodel(kunderaMetadata,
entityMetadata.getPersistenceUnit());
String idColumnName = ((AbstractAttribute) entityMetadata.getIdAttribute()).getJPAColumnName();
Table schemaTable = tableAPI.getTable(entityMetadata.getTableName());
PrimaryKey rowKey = schemaTable.createPrimaryKey();
if (metamodel.isEmbeddable(entityMetadata.getIdAttribute().getBindableJavaType()))
{
readEmbeddable(key, columnsToSelect, entityMetadata, metamodel, schemaTable, rowKey,
entityMetadata.getIdAttribute());
}
else
{
if (eligibleToFetch(columnsToSelect, idColumnName))
{
NoSqlDBUtils.add(schemaTable.getField(idColumnName), rowKey, key, idColumnName);
}
}
KunderaCoreUtils.printQuery("Fetch data from " + entityMetadata.getTableName() + " for PK " + key, showQuery);
if (log.isDebugEnabled())
{
log.debug("Fetching data from " + entityMetadata.getTableName() + " for PK " + key);
}
// Object entity = null;
List entities = new ArrayList();
Map<String, Object> relationMap = initialize(entityMetadata);
try
{
Iterator<Row> rowsIter = tableAPI.tableIterator(rowKey, null, null);
// iterator and build entity
entities = scrollAndPopulate(key, entityMetadata, metamodel, schemaTable, rowsIter, relationMap,
columnsToSelect);
}
catch (Exception e)
{
log.error("Error while finding data for Key " + key + ", Caused By :" + e + ".");
throw new PersistenceException(e);
}
return entities.isEmpty() ? null : entities.get(0);
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.