/** * Compose and add. * * @param entity * the entity * @param cqlMetadata * the cql metadata * @param thriftColumnValue * the thrift column value * @param thriftColumnName * the thrift column name */ 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))); }
/** * Compose column value. * * @param cqlMetadata * the cql metadata * @param thriftColumnValue * the thrift column value * @param thriftColumnName * the thrift column name * @return the object */ private Object composeColumnValue(CqlMetadata cqlMetadata, byte[] thriftColumnValue, byte[] thriftColumnName) { Map<ByteBuffer, String> schemaTypes = cqlMetadata.getValue_types(); AbstractType<?> type = null; try { type = TypeParser.parse(schemaTypes.get(ByteBuffer.wrap(thriftColumnName))); } catch (SyntaxException | ConfigurationException ex) { log.error(ex.getMessage()); throw new KunderaException("Error while deserializing column value " + ex); } if (type.isCollection()) { return ((CollectionSerializer) type.getSerializer()) .deserializeForNativeProtocol(ByteBuffer.wrap(thriftColumnValue), ProtocolVersion.V2); } return type.compose(ByteBuffer.wrap(thriftColumnValue)); }
log.error(e.getMessage()); throw new KunderaException("Error while getting instance of ListType " + e); log.error(e.getMessage()); throw new KunderaException("Error while getting instance of SetType " + e); log.error(e.getMessage()); throw new KunderaException("Error while getting instance of MapType " + e);
log.error(e.getMessage()); throw new KunderaException("Error while getting instance of UserType " + e);
public static InvalidRequestException toThrift(RequestValidationException e) { return new InvalidRequestException(e.getMessage()); }
public static InvalidRequestException toThrift(RequestValidationException e) { return new InvalidRequestException(e.getMessage()); }
public static InvalidRequestException toThrift(RequestValidationException e) { return new InvalidRequestException(e.getMessage()); }
public static <T extends ParsedStatement> T parseStatement(String queryStr, Class<T> klass, String type) throws SyntaxException { try { ParsedStatement stmt = parseStatement(queryStr); if (!klass.isAssignableFrom(stmt.getClass())) throw new IllegalArgumentException("Invalid query, must be a " + type + " statement but was: " + stmt.getClass()); return klass.cast(stmt); } catch (RequestValidationException e) { throw new IllegalArgumentException(e.getMessage(), e); } } public static ParsedStatement parseStatement(String queryStr) throws SyntaxException
public static <T extends ParsedStatement> T parseStatement(String queryStr, Class<T> klass, String type) throws SyntaxException { try { ParsedStatement stmt = parseStatement(queryStr); if (!klass.isAssignableFrom(stmt.getClass())) throw new IllegalArgumentException("Invalid query, must be a " + type + " statement but was: " + stmt.getClass()); return klass.cast(stmt); } catch (RequestValidationException e) { throw new IllegalArgumentException(e.getMessage(), e); } } public static ParsedStatement parseStatement(String queryStr) throws SyntaxException
public static <T extends ParsedStatement> T parseStatement(String queryStr, Class<T> klass, String type) throws SyntaxException { try { ParsedStatement stmt = parseStatement(queryStr); if (!klass.isAssignableFrom(stmt.getClass())) throw new IllegalArgumentException("Invalid query, must be a " + type + " statement but was: " + stmt.getClass()); return klass.cast(stmt); } catch (RequestValidationException e) { throw new IllegalArgumentException(e.getMessage(), e); } } public static ParsedStatement parseStatement(String queryStr) throws SyntaxException
@Around("selectAll()") public Object handleException(ProceedingJoinPoint pjp) throws Throwable { int errorCode = ErrorCodes.GENERAL_SYSTEM_ERROR; if(sowEx.getErrorCode() != 0) errorCode = sowEx.getErrorCode(); SowResult retVal = null; try { retVal = (SowResult) pjp.proceed(); } catch (RequestValidationException sowEx) { //now return the error response return new SowResult(Consts.SOW_RESULT_ERROR, errorCode, sowEx.getMessage(), "islem hata almistir!!"); } return retVal; }
private static <T extends CQLStatement> Pair<T, List<ColumnSpecification>> getStatement(String query, Class<T> klass, String type) { try { ClientState state = ClientState.forInternalCalls(); ParsedStatement.Prepared prepared = QueryProcessor.getStatement(query, state); CQLStatement stmt = prepared.statement; stmt.validate(state); if (!stmt.getClass().equals(klass)) throw new IllegalArgumentException("Invalid query, must be a " + type + " statement"); return Pair.create(klass.cast(stmt), prepared.boundNames); } catch (RequestValidationException e) { throw new IllegalArgumentException(e.getMessage(), e); } }
public static AbstractType toType(Pair<DataType, Object> entry) { try { switch (entry.left) { case CUSTOM: return TypeParser.parse((String)entry.right); case LIST: return ListType.getInstance((AbstractType)entry.right, true); case SET: return SetType.getInstance((AbstractType)entry.right, true); case MAP: List<AbstractType> l = (List<AbstractType>)entry.right; return MapType.getInstance(l.get(0), l.get(1), true); case UDT: return (AbstractType)entry.right; case TUPLE: return (AbstractType)entry.right; default: return entry.left.type; } } catch (RequestValidationException e) { throw new ProtocolException(e.getMessage()); } }
public static AbstractType toType(Pair<DataType, Object> entry) { try { switch (entry.left) { case CUSTOM: return TypeParser.parse((String)entry.right); case LIST: return ListType.getInstance((AbstractType)entry.right, true); case SET: return SetType.getInstance((AbstractType)entry.right, true); case MAP: List<AbstractType> l = (List<AbstractType>)entry.right; return MapType.getInstance(l.get(0), l.get(1), true); case UDT: return (AbstractType)entry.right; case TUPLE: return (AbstractType)entry.right; default: return entry.left.type; } } catch (RequestValidationException e) { throw new ProtocolException(e.getMessage()); } }
public static AbstractType toType(Pair<DataType, Object> entry) { try { switch (entry.left) { case CUSTOM: return TypeParser.parse((String)entry.right); case LIST: return ListType.getInstance((AbstractType)entry.right, true); case SET: return SetType.getInstance((AbstractType)entry.right, true); case MAP: List<AbstractType> l = (List<AbstractType>)entry.right; return MapType.getInstance(l.get(0), l.get(1), true); case UDT: return (AbstractType)entry.right; case TUPLE: return (AbstractType)entry.right; default: return entry.left.type; } } catch (RequestValidationException e) { throw new ProtocolException(e.getMessage()); } }
public static AbstractType toType(Pair<DataType, Object> entry) { try { switch (entry.left) { case CUSTOM: return TypeParser.parse((String)entry.right); case LIST: return ListType.getInstance((AbstractType)entry.right, true); case SET: return SetType.getInstance((AbstractType)entry.right, true); case MAP: List<AbstractType> l = (List<AbstractType>)entry.right; return MapType.getInstance(l.get(0), l.get(1), true); case UDT: return (AbstractType)entry.right; case TUPLE: return (AbstractType)entry.right; default: return entry.left.type; } } catch (RequestValidationException e) { throw new ProtocolException(e.getMessage()); } }
public static AbstractType toType(Pair<DataType, Object> entry) { try { switch (entry.left) { case CUSTOM: return TypeParser.parse((String)entry.right); case LIST: return ListType.getInstance((AbstractType)entry.right, true); case SET: return SetType.getInstance((AbstractType)entry.right, true); case MAP: List<AbstractType> l = (List<AbstractType>)entry.right; return MapType.getInstance(l.get(0), l.get(1), true); case UDT: return (AbstractType)entry.right; case TUPLE: return (AbstractType)entry.right; default: return entry.left.type; } } catch (RequestValidationException e) { throw new ProtocolException(e.getMessage()); } } }
throw new IllegalArgumentException(e.getMessage(), e);