Uses of Class org.apache.hadoop.hbase.hbql.client.HBqlException (HBql 0.90.0.1 API)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Class
org.apache.hadoop.hbase.hbql.client.HBqlException

Packages that use HBqlException
org.apache.expreval.client
org.apache.expreval.expr
org.apache.expreval.expr.betweenstmt
org.apache.expreval.expr.calculation
org.apache.expreval.expr.casestmt
org.apache.expreval.expr.compare
org.apache.expreval.expr.function
org.apache.expreval.expr.ifthenstmt
org.apache.expreval.expr.instmt
org.apache.expreval.expr.literal
org.apache.expreval.expr.node
org.apache.expreval.expr.nullcomp
org.apache.expreval.expr.stringpattern
org.apache.expreval.expr.var
org.apache.hadoop.hbase.hbql
org.apache.hadoop.hbase.hbql.client
org.apache.hadoop.hbase.hbql.executor
org.apache.hadoop.hbase.hbql.filter
org.apache.hadoop.hbase.hbql.impl
org.apache.hadoop.hbase.hbql.index
org.apache.hadoop.hbase.hbql.io
org.apache.hadoop.hbase.hbql.mapping
org.apache.hadoop.hbase.hbql.parser
org.apache.hadoop.hbase.hbql.statement
org.apache.hadoop.hbase.hbql.statement.args
org.apache.hadoop.hbase.hbql.statement.select
org.apache.hadoop.hbase.hbql.util
org.apache.hadoop.hbase.jdbc
org.apache.hadoop.hbase.jdbc.impl
org.apache.yaoql.client
org.apache.yaoql.impl

Uses of HBqlException in org.apache.expreval.client

Subclasses of HBqlException in org.apache.expreval.client
`class`	`InternalErrorException`

Uses of HBqlException in org.apache.expreval.expr

Methods in org.apache.expreval.expr that throw HBqlException
`void`	`GenericExpression.applyResultToAggregateValue(AggregateValue aggregateValue, org.apache.hadoop.hbase.client.Result result)`
`Object`	`MultipleExpressionContext.evaluate(HConnectionImpl conn, int i, boolean allowColumns, boolean allowCollections, Object object)`
`Boolean`	`ExpressionTree.evaluate(HConnectionImpl conn, Object object)`
`Object`	`MultipleExpressionContext.evaluateConstant(int i, boolean allowCollections)`
`boolean`	`ExpressionProperty.getBooleanValue()`
`org.apache.hadoop.hbase.filter.CompareFilter.CompareOp`	`Operator.getCompareOpLeft()`
`org.apache.hadoop.hbase.filter.CompareFilter.CompareOp`	`Operator.getCompareOpRight()`
`protected Object`	`GenericExpression.getConstantValue(int pos)`
`org.apache.hadoop.hbase.filter.Filter`	`GenericExpression.getFilter()`
`org.apache.hadoop.hbase.filter.Filter`	`ExpressionTree.getFilter()`
`int`	`ExpressionProperty.getIntegerValue()`
`Mapping`	`MultipleExpressionContext.getMapping()`
`GenericValue`	`GenericExpression.getOptimizedValue()`
`GenericValue`	`BooleanNot.getOptimizedValue()`
`ResultAccessor`	`MultipleExpressionContext.getResultAccessor()`
`Boolean`	`BooleanNot.getValue(HConnectionImpl conn, Object object)`
`protected Number`	`GenericExpression.getValueWithCast(double result)`
`protected Number`	`GenericExpression.getValueWithCast(long result)`
`void`	`GenericExpression.initAggregateValue(AggregateValue aggregateValue)`
`GenericValue`	`TypeSignature.newLiteral(Object val)`
`protected org.apache.hadoop.hbase.filter.Filter`	`GenericExpression.newSingleColumnValueFilter(ColumnAttrib attrib, org.apache.hadoop.hbase.filter.CompareFilter.CompareOp compareOp, org.apache.hadoop.hbase.filter.WritableByteArrayComparable comparator)`
`void`	`MultipleExpressionContext.optimize()`
`protected void`	`GenericExpression.optimizeAllArgs()`
`void`	`ExpressionTree.setEmbeddedMapping()`
`void`	`GenericExpression.setExpressionContext(MultipleExpressionContext expressionContext)`
`void`	`MultipleExpressionContext.setMappingContext(MappingContext mappingContext)`
`int`	`MultipleExpressionContext.setParameter(String name, Object val)`
`protected void`	`DelegateStmt.setTypedExpr(T typedExpr)`
`void`	`ExpressionProperty.validate()`
`protected Class<? extends GenericValue>`	`GenericExpression.validateNumericTypes()`
`void`	`MultipleExpressionContext.validateTypes(boolean allowColumns, boolean allowCollections)`
`Class<? extends GenericValue>`	`GenericExpression.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`BooleanNot.validateTypes(GenericValue parentExpr, boolean allowCollections)`

Uses of HBqlException in org.apache.expreval.expr.betweenstmt

Methods in org.apache.expreval.expr.betweenstmt that throw HBqlException
`org.apache.hadoop.hbase.filter.Filter`	`StringBetweenStmt.getFilter()`
`org.apache.hadoop.hbase.filter.Filter`	`NumberBetweenStmt.getFilter()`
`org.apache.hadoop.hbase.filter.Filter`	`DelegateBetweenStmt.getFilter()`
`org.apache.hadoop.hbase.filter.Filter`	`DateBetweenStmt.getFilter()`
`org.apache.hadoop.hbase.filter.Filter`	`ByteBetweenStmt.getFilter()`
`GenericValue`	`DelegateBetweenStmt.getOptimizedValue()`
`Boolean`	`StringBetweenStmt.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`NumberBetweenStmt.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`DelegateBetweenStmt.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`DateBetweenStmt.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`ByteBetweenStmt.getValue(HConnectionImpl conn, Object object)`
`Class<? extends GenericValue>`	`DelegateBetweenStmt.validateTypes(GenericValue parentExpr, boolean allowCollections)`

Uses of HBqlException in org.apache.expreval.expr.calculation

Methods in org.apache.expreval.expr.calculation that throw HBqlException
`GenericValue`	`DelegateCalculation.getOptimizedValue()`
`String`	`StringCalculation.getValue(HConnectionImpl conn, Object object)`
`Number`	`NumericCalculation.getValue(HConnectionImpl conn, Object object)`
`Object`	`DelegateCalculation.getValue(HConnectionImpl conn, Object object)`
`Long`	`DateCalculation.getValue(HConnectionImpl conn, Object object)`
`Class<? extends GenericValue>`	`NumericCalculation.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`DelegateCalculation.validateTypes(GenericValue parentExpr, boolean allowCollections)`

Uses of HBqlException in org.apache.expreval.expr.casestmt

Methods in org.apache.expreval.expr.casestmt that throw HBqlException
`GenericValue`	`DelegateCaseWhen.getOptimizedValue()`
`GenericValue`	`DelegateCaseElse.getOptimizedValue()`
`GenericValue`	`DelegateCase.getOptimizedValue()`
`boolean`	`GenericCaseWhen.getPredicateValue(HConnectionImpl conn, Object object)`
`String`	`StringCaseWhen.getValue(HConnectionImpl conn, Object object)`
`String`	`StringCaseElse.getValue(HConnectionImpl conn, Object object)`
`String`	`StringCase.getValue(HConnectionImpl conn, Object object)`
`Number`	`NumberCaseWhen.getValue(HConnectionImpl conn, Object object)`
`Number`	`NumberCaseElse.getValue(HConnectionImpl conn, Object object)`
`Number`	`NumberCase.getValue(HConnectionImpl conn, Object object)`
`Object`	`GenericCaseWhen.getValue(HConnectionImpl conn, Object object)`
`Object`	`GenericCaseElse.getValue(HConnectionImpl conn, Object object)`
`Object`	`GenericCase.getValue(HConnectionImpl conn, Object object)`
`Object`	`DelegateCaseWhen.getValue(HConnectionImpl conn, Object object)`
`Object`	`DelegateCaseElse.getValue(HConnectionImpl conn, Object object)`
`Object`	`DelegateCase.getValue(HConnectionImpl conn, Object object)`
`Long`	`DateCaseWhen.getValue(HConnectionImpl conn, Object object)`
`Long`	`DateCaseElse.getValue(HConnectionImpl conn, Object object)`
`Long`	`DateCase.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`BooleanCaseWhen.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`BooleanCaseElse.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`BooleanCase.getValue(HConnectionImpl conn, Object object)`
`Class<? extends GenericValue>`	`DelegateCaseWhen.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`DelegateCaseElse.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`DelegateCase.validateTypes(GenericValue parentExpr, boolean allowCollections)`

Uses of HBqlException in org.apache.expreval.expr.compare

Methods in org.apache.expreval.expr.compare that throw HBqlException
`org.apache.hadoop.hbase.filter.Filter`	`StringCompare.getFilter()`
`org.apache.hadoop.hbase.filter.Filter`	`NumberCompare.getFilter()`
`org.apache.hadoop.hbase.filter.Filter`	`DelegateCompare.getFilter()`
`org.apache.hadoop.hbase.filter.Filter`	`DateCompare.getFilter()`
`org.apache.hadoop.hbase.filter.Filter`	`ByteCompare.getFilter()`
`org.apache.hadoop.hbase.filter.Filter`	`BooleanCompare.getFilter()`
`GenericValue`	`GenericCompare.getOptimizedValue()`
`GenericValue`	`DelegateCompare.getOptimizedValue()`
`Boolean`	`StringCompare.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`NumberCompare.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`DelegateCompare.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`DateCompare.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`ByteCompare.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`BooleanCompare.getValue(HConnectionImpl conn, Object object)`
`protected Object`	`GenericCompare.getValue(int pos, HConnectionImpl conn, Object object)`
`Class<? extends GenericValue>`	`StringCompare.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`NumberCompare.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`DelegateCompare.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`DateCompare.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`ByteCompare.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`BooleanCompare.validateTypes(GenericValue parentExpr, boolean allowCollections)`

Uses of HBqlException in org.apache.expreval.expr.function

Methods in org.apache.expreval.expr.function that throw HBqlException
`void`	`NumberFunction.applyResultToAggregateValue(AggregateValue aggVal, org.apache.hadoop.hbase.client.Result result)`
`void`	`DelegateFunction.applyResultToAggregateValue(AggregateValue aggregateValue, org.apache.hadoop.hbase.client.Result result)`
`GenericValue`	`GenericFunction.getOptimizedValue()`
`GenericValue`	`DelegateFunction.getOptimizedValue()`
`String`	`StringFunction.getValue(HConnectionImpl conn, Object object)`
`Number`	`NumberFunction.getValue(HConnectionImpl conn, Object object)`
`Object`	`DelegateFunction.getValue(HConnectionImpl conn, Object object)`
`Long`	`DateFunction.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`BooleanFunction.getValue(HConnectionImpl conn, Object object)`
`void`	`NumberFunction.initAggregateValue(AggregateValue aggregateValue)`
`void`	`DelegateFunction.initAggregateValue(AggregateValue aggregateValue)`
`Class<? extends GenericValue>`	`GenericFunction.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`DelegateFunction.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`BooleanFunction.validateTypes(GenericValue parentExpr, boolean allowCollections)`

Uses of HBqlException in org.apache.expreval.expr.ifthenstmt

Methods in org.apache.expreval.expr.ifthenstmt that throw HBqlException
`GenericValue`	`DelegateIfThen.getOptimizedValue()`
`String`	`StringIfThen.getValue(HConnectionImpl conn, Object object)`
`Number`	`NumberIfThen.getValue(HConnectionImpl conn, Object object)`
`Object`	`GenericIfThen.getValue(HConnectionImpl conn, Object object)`
`Object`	`DelegateIfThen.getValue(HConnectionImpl conn, Object object)`
`Long`	`DateIfThen.getValue(HConnectionImpl conn, Object object)`
`Byte`	`ByteIfThen.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`BooleanIfThen.getValue(HConnectionImpl conn, Object object)`
`Class<? extends GenericValue>`	`DelegateIfThen.validateTypes(GenericValue parentExpr, boolean allowCollections)`

Uses of HBqlException in org.apache.expreval.expr.instmt

Methods in org.apache.expreval.expr.instmt that throw HBqlException
`protected boolean`	`StringInStmt.evaluateInList(Object object)`
`protected boolean`	`NumberInStmt.evaluateInList(Object object)`
`protected abstract boolean`	`GenericInStmt.evaluateInList(Object object)`
`protected boolean`	`DelegateInStmt.evaluateInList(Object object)`
`protected boolean`	`DateInStmt.evaluateInList(Object object)`
`protected boolean`	`BooleanInStmt.evaluateInList(Object object)`
`org.apache.hadoop.hbase.filter.Filter`	`StringInStmt.getFilter()`
`org.apache.hadoop.hbase.filter.Filter`	`DelegateInStmt.getFilter()`
`GenericValue`	`DelegateInStmt.getOptimizedValue()`
`Boolean`	`GenericInStmt.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`DelegateInStmt.getValue(HConnectionImpl conn, Object object)`
`Class<? extends GenericValue>`	`GenericInStmt.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`DelegateInStmt.validateTypes(GenericValue parentExpr, boolean allowCollections)`

Uses of HBqlException in org.apache.expreval.expr.literal

Methods in org.apache.expreval.expr.literal that throw HBqlException
`void`	`GenericLiteral.applyResultToAggregateValue(AggregateValue aggregateValue, org.apache.hadoop.hbase.client.Result result)`
`void`	`DefaultKeyword.applyResultToAggregateValue(AggregateValue aggregateValue, org.apache.hadoop.hbase.client.Result result)`
`org.apache.hadoop.hbase.filter.Filter`	`GenericLiteral.getFilter()`
`org.apache.hadoop.hbase.filter.Filter`	`DefaultKeyword.getFilter()`
`GenericValue`	`GenericLiteral.getOptimizedValue()`
`void`	`GenericLiteral.initAggregateValue(AggregateValue aggregateValue)`
`void`	`DefaultKeyword.initAggregateValue(AggregateValue aggregateValue)`
`Class<? extends GenericValue>`	`GenericLiteral.validateTypes(GenericValue parentExpr, boolean allowCollections)`

Uses of HBqlException in org.apache.expreval.expr.node

Methods in org.apache.expreval.expr.node that throw HBqlException
`void`	`GenericValue.applyResultToAggregateValue(AggregateValue aggregateValue, org.apache.hadoop.hbase.client.Result result)`
`org.apache.hadoop.hbase.filter.Filter`	`GenericValue.getFilter()`
`GenericValue`	`GenericValue.getOptimizedValue()`
`String`	`StringValue.getValue(HConnectionImpl connection, Object object)`
`Short`	`ShortValue.getValue(HConnectionImpl connection, Object object)`
`Object`	`ObjectValue.getValue(HConnectionImpl connection, Object object)`
`Number`	`NumberValue.getValue(HConnectionImpl connection, Object object)`
`Long`	`LongValue.getValue(HConnectionImpl connection, Object object)`
`Integer`	`IntegerValue.getValue(HConnectionImpl connection, Object object)`
`Object`	`GenericValue.getValue(HConnectionImpl connection, Object object)`
`Float`	`FloatValue.getValue(HConnectionImpl connection, Object object)`
`Double`	`DoubleValue.getValue(HConnectionImpl connection, Object object)`
`Long`	`DateValue.getValue(HConnectionImpl connection, Object object)`
`Short`	`CharValue.getValue(HConnectionImpl connection, Object object)`
`Byte`	`ByteValue.getValue(HConnectionImpl connection, Object object)`
`Boolean`	`BooleanValue.getValue(HConnectionImpl connection, Object object)`
`void`	`GenericValue.initAggregateValue(AggregateValue aggregateValue)`
`void`	`GenericValue.setExpressionContext(MultipleExpressionContext context)`
`Class<? extends GenericValue>`	`GenericValue.validateTypes(GenericValue parentExpr, boolean allowCollections)`

Uses of HBqlException in org.apache.expreval.expr.nullcomp

Methods in org.apache.expreval.expr.nullcomp that throw HBqlException
`GenericValue`	`DelegateNullCompare.getOptimizedValue()`
`Boolean`	`GenericNullCompare.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`DelegateNullCompare.getValue(HConnectionImpl conn, Object object)`
`Class<? extends GenericValue>`	`DelegateNullCompare.validateTypes(GenericValue parentExpr, boolean allowCollections)`

Uses of HBqlException in org.apache.expreval.expr.stringpattern

Methods in org.apache.expreval.expr.stringpattern that throw HBqlException
`Boolean`	`LikeStmt.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`ContainsStmt.getValue(HConnectionImpl conn, Object object)`

Uses of HBqlException in org.apache.expreval.expr.var

Methods in org.apache.expreval.expr.var that throw HBqlException
`void`	`NamedParameter.applyResultToAggregateValue(AggregateValue aggregateValue, org.apache.hadoop.hbase.client.Result result)`
`void`	`GenericColumn.applyResultToAggregateValue(AggregateValue aggregateValue, org.apache.hadoop.hbase.client.Result result)`
`org.apache.hadoop.hbase.filter.Filter`	`NamedParameter.getFilter()`
`org.apache.hadoop.hbase.filter.Filter`	`GenericColumn.getFilter()`
`GenericValue`	`NamedParameter.getOptimizedValue()`
`T`	`GenericColumn.getOptimizedValue()`
`Object`	`StringColumn.getValue(HConnectionImpl conn, Object object)`
`Short`	`ShortColumn.getValue(HConnectionImpl conn, Object object)`
`Object`	`ObjectColumn.getValue(HConnectionImpl conn, Object object)`
`Object`	`NamedParameter.getValue(HConnectionImpl conn, Object object)`
`Long`	`LongColumn.getValue(HConnectionImpl conn, Object object)`
`Object`	`KeyColumn.getValue(HConnectionImpl conn, Object object)`
`Integer`	`IntegerColumn.getValue(HConnectionImpl conn, Object object)`
`Float`	`FloatColumn.getValue(HConnectionImpl conn, Object object)`
`Double`	`DoubleColumn.getValue(HConnectionImpl conn, Object object)`
`Object`	`DelegateColumn.getValue(HConnectionImpl conn, Object object)`
`Long`	`DateColumn.getValue(HConnectionImpl conn, Object object)`
`Short`	`CharColumn.getValue(HConnectionImpl conn, Object object)`
`Byte`	`ByteColumn.getValue(HConnectionImpl conn, Object object)`
`Boolean`	`BooleanColumn.getValue(HConnectionImpl conn, Object object)`
`void`	`NamedParameter.initAggregateValue(AggregateValue aggregateValue)`
`void`	`GenericColumn.initAggregateValue(AggregateValue aggregateValue)`
`void`	`GenericColumn.setExpressionContext(MultipleExpressionContext context)`
`void`	`DelegateColumn.setExpressionContext(MultipleExpressionContext context)`
`void`	`NamedParameter.setParameter(Object val)`
`Class<? extends GenericValue>`	`NamedParameter.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`GenericColumn.validateTypes(GenericValue parentExpr, boolean allowCollections)`
`Class<? extends GenericValue>`	`DelegateColumn.validateTypes(GenericValue parentExpr, boolean allowCollections)`

Uses of HBqlException in org.apache.hadoop.hbase.hbql

Methods in org.apache.hadoop.hbase.hbql that throw HBqlException
`static void`	`Console.main(String[] args)`

Uses of HBqlException in org.apache.hadoop.hbase.hbql.client

Methods in org.apache.hadoop.hbase.hbql.client that return HBqlException
`HBqlException`	`QueryFuture.getHBqlException()`

Methods in org.apache.hadoop.hbase.hbql.client with parameters of type HBqlException
`void`	`QueryListener.onException(QueryListener.ExceptionSource source, HBqlException e)`
`void`	`QueryListenerAdapter.onHBqlException(HBqlException e)`

Methods in org.apache.hadoop.hbase.hbql.client that throw HBqlException

void HBatch.apply()

String HMapping.asString()

void HStatement.close()

HStatement HConnection.createStatement()

void HBatch.delete(T newrec)

void HConnection.disableTable(String tableName)

void HConnection.dropIndexForMapping(String indexName, String mappingName)

void HConnection.dropIndexForTable(String tableName, String indexName)

void HMapping.dropMapping()

boolean HConnection.dropMapping(String mappingName)

void HConnection.dropTable(String tableName)

void HConnection.enableTable(String tableName)

ExecutionResults HPreparedStatement.execute()

ExecutionResults HStatement.execute(String sql)

ExecutionResults HConnection.execute(String sql)

HResultSet<HRecord> HPreparedStatement.executeQuery()





<T> HResultSet<T>

HPreparedStatement.executeQuery(Class clazz)

HResultSet<HRecord> HConnection.executeQuery(String sql)





<T> HResultSet<T>

HConnection.executeQuery(String sql,
             Class clazz)





<T> HResultSet<T>

HStatement.executeQuery(String sql,
             Class clazz,
             QueryListener<T>... listeners)

HResultSet<HRecord> HStatement.executeQuery(String sql, QueryListener<HRecord>... listeners)

List<HRecord> HPreparedStatement.executeQueryAndFetch()





<T> List<T>

HPreparedStatement.executeQueryAndFetch(Class clazz)

List<HRecord> HConnection.executeQueryAndFetch(String sql)





<T> List<T>

HConnection.executeQueryAndFetch(String sql,
                     Class clazz)





<T> List<T>

HStatement.executeQueryAndFetch(String sql,
                     Class clazz,
                     QueryListener<T>... listeners)

List<HRecord> HStatement.executeQueryAndFetch(String sql, QueryListener<HRecord>... listeners)





<T> QueryFuture

HStatement.executeQueryAsync(String sql,
                  Class clazz,
                  QueryListener<T>... listeners)

QueryFuture HStatement.executeQueryAsync(String sql, QueryListener<HRecord>... listeners)

ExecutionResults HPreparedStatement.executeUpdate()

ExecutionResults HStatement.executeUpdate(String sql)

ExecutionResults HConnection.executeUpdate(String sql)

Set<HMapping> HConnection.getAllMappings()

static AsyncExecutor AsyncExecutorManager.getAsyncExecutor(String name)

Set<String> HRecord.getColumnNameList()

Object HRecord.getCurrentValue(String name)

Set<String> HConnection.getFamilyNames(String tableName)

org.apache.hadoop.hbase.HTableDescriptor HConnection.getHTableDescriptor(String tableName)

HMapping HConnection.getMapping(String mappingName)

static QueryExecutorPool QueryExecutorPoolManager.getQueryExecutorPool(String poolName)

Set<String> HConnection.getTableNames()

Map<String,byte[]> HRecord.getUnMappedValueMap(String familyName)

Map<String,NavigableMap<Long,byte[]>> HRecord.getUnMappedVersionMap(String familyName)

Map<Long,Object> HRecord.getVersionMap(String name)

static String Util.getZeroPaddedNonNegativeNumber(long val, int width)

boolean HConnection.indexExistsForMapping(String indexName, String mappingName)

boolean HConnection.indexExistsForTable(String indexName, String tableName)

void HBatch.insert(T newrec)

boolean HConnection.isClosed()

boolean HConnection.mappingExists(String mappingName)

static AsyncExecutor AsyncExecutorManager.newAsyncExecutor(String name, int minThreadCount, int maxThreadCount, long keepAliveSecs)

static HConnection HConnectionManager.newConnection()

static HConnection HConnectionManager.newConnection(org.apache.hadoop.conf.Configuration config)

static HConnectionPool HConnectionPoolManager.newConnectionPool(int initialPoolSize, int maxPoolSize)

static HConnectionPool HConnectionPoolManager.newConnectionPool(int initialPoolSize, int maxPoolSize, org.apache.hadoop.hbase.HBaseConfiguration config)

static HConnectionPool HConnectionPoolManager.newConnectionPool(int initialPoolSize, int maxPoolSize, String poolName)

static HConnectionPool HConnectionPoolManager.newConnectionPool(int initialPoolSize, int maxPoolSize, String poolName, org.apache.hadoop.hbase.HBaseConfiguration config)

HRecord HMapping.newHRecord()

HRecord HMapping.newHRecord(Map<String,Object> initMap)

static QueryExecutorPool QueryExecutorPoolManager.newQueryExecutorPool(String poolName, int maxExecutorPoolSize, int minThreadCount, int maxThreadCount, long keepAliveSecs, boolean threadsReadResults, int completionQueueSize)

void QueryListenerAdapter.onEachRow(T val)

void QueryListener.onEachRow(T val)

void QueryListenerAdapter.onQueryComplete()

void QueryListener.onQueryComplete()

void QueryListenerAdapter.onQueryStart()

void QueryListener.onQueryStart()

HPreparedStatement HConnection.prepareStatement(String str)

void HPreparedStatement.resetParameters()

void HRecord.setCurrentValue(String name, Object val)

void HPreparedStatement.setParameter(int i, Object obj)

int HPreparedStatement.setParameter(String name, Object val)

boolean HConnection.tableEnabled(String tableName)

boolean HConnection.tableExists(String tableName)

HConnection HConnectionPool.takeConnection()

Constructors in org.apache.hadoop.hbase.hbql.client that throw HBqlException
`UnMappedValueMap(String familyName)`

Uses of HBqlException in org.apache.hadoop.hbase.hbql.executor

Methods in org.apache.hadoop.hbase.hbql.executor that throw HBqlException
`int`	`QueryExecutorPoolDefinition.getCompletionQueueSize()`
`long`	`QueryExecutorPoolDefinition.getKeepAliveSecs()`
`long`	`AsyncExecutorDefinition.getKeepAliveSecs()`
`int`	`QueryExecutorPoolDefinition.getMaxExecutorPoolSize()`
`int`	`QueryExecutorPoolDefinition.getMaxThreadCount()`
`int`	`AsyncExecutorDefinition.getMaxThreadCount()`
`int`	`QueryExecutorPoolDefinition.getMinThreadCount()`
`int`	`AsyncExecutorDefinition.getMinThreadCount()`
`boolean`	`QueryExecutorPoolDefinition.getThreadsReadResults()`
`void`	`QueryExecutorPoolDefinition.validateExecutorPoolPropertyList()`
`void`	`AsyncExecutorDefinition.validatePropertyList()`

Uses of HBqlException in org.apache.hadoop.hbase.hbql.filter

Methods in org.apache.hadoop.hbase.hbql.filter that throw HBqlException
`static void`	`RecordFilter.testFilter(RecordFilter origFilter)`

Uses of HBqlException in org.apache.hadoop.hbase.hbql.impl

Subclasses of HBqlException in org.apache.hadoop.hbase.hbql.impl
`class`	`ColumnNotAllowedException`
`class`	`InvalidColumnException`
`class`	`InvalidFunctionException`
`class`	`InvalidIndexExpressionException`
`class`	`InvalidServerFilterException`
`class`	`InvalidTypeException`
`class`	`ParseException`

Methods in org.apache.hadoop.hbase.hbql.impl that return HBqlException
`HBqlException`	`QueryFutureImpl.getHBqlException()`

Methods in org.apache.hadoop.hbase.hbql.impl with parameters of type HBqlException
`void`	`CompletionQueueExecutor.addException(HBqlException exception)`
`protected void`	`Query.callOnException(HBqlException e)`
`void`	`QueryFutureImpl.setCaughtException(HBqlException exception)`

Methods in org.apache.hadoop.hbase.hbql.impl that throw HBqlException

void ElementMap.addElement(T value)

void HRecordImpl.addElement(Value value)

protected void ElementPool.addElementToPool()

void InsertAction.apply(org.apache.hadoop.hbase.client.HTableInterface table)

void DeleteAction.apply(org.apache.hadoop.hbase.client.HTableInterface table)

void BatchAction.apply(org.apache.hadoop.hbase.client.HTableInterface table)

void AggregateValue.applyValues(org.apache.hadoop.hbase.client.Result result)

void AggregateRecord.applyValues(org.apache.hadoop.hbase.client.Result result)

static void HPreparedStatementImpl.checkForNullParameterValue(Object val)

void HStatementImpl.close()

TableMapping MappingManager.createMapping(boolean isTemp, boolean isSystem, String mappingName, String tableName, KeyInfo keyInfo, List<FamilyMapping> familyMappingList)

TableMapping HConnectionImpl.createMapping(boolean tempMapping, boolean systemMapping, String mappingName, String tableName, KeyInfo keyInfo, List<FamilyMapping> familyList)

HStatement HConnectionImpl.createStatement()

void HConnectionImpl.createTable(org.apache.hadoop.hbase.HTableDescriptor tableDesc)

void HConnectionImpl.disableTable(String tableName)

void HConnectionImpl.dropIndexForMapping(String indexName, String mappingName)

void HConnectionImpl.dropIndexForTable(String tableName, String indexName)

boolean MappingManager.dropMapping(String mappingName)

boolean HConnectionImpl.dropMapping(String mappingName)

void HConnectionImpl.dropTable(String tableName)

void HConnectionImpl.enableTable(String tableName)

ExecutionResults HPreparedStatementImpl.execute()

protected ExecutionResults HStatementImpl.execute(HBqlStatement statement)

ExecutionResults HStatementImpl.execute(String sql)

ExecutionResults HConnectionImpl.execute(String sql)

HResultSet<HRecord> HPreparedStatementImpl.executeQuery()





<T> HResultSet<T>

HPreparedStatementImpl.executeQuery(Class clazz)

protected 



<T> HResultSet<T>

HStatementImpl.executeQuery(HBqlStatement statement,
             Class clazz,
             QueryListener<T>... listeners)

HResultSet<HRecord> HConnectionImpl.executeQuery(String sql)





<T> HResultSet<T>

HConnectionImpl.executeQuery(String sql,
             Class clazz)





<T> HResultSet<T>

HStatementImpl.executeQuery(String sql,
             Class clazz,
             QueryListener<T>... listeners)

HResultSet<HRecord> HStatementImpl.executeQuery(String sql, QueryListener<HRecord>... listeners)

List<HRecord> HPreparedStatementImpl.executeQueryAndFetch()





<T> List<T>

HPreparedStatementImpl.executeQueryAndFetch(Class clazz)

protected 



<T> List<T>

HStatementImpl.executeQueryAndFetch(HBqlStatement statement,
                     Class clazz,
                     QueryListener<T>... listeners)

List<HRecord> HConnectionImpl.executeQueryAndFetch(String sql)





<T> List<T>

HConnectionImpl.executeQueryAndFetch(String sql,
                     Class clazz)





<T> List<T>

HStatementImpl.executeQueryAndFetch(String sql,
                     Class clazz,
                     QueryListener<T>... listeners)

List<HRecord> HStatementImpl.executeQueryAndFetch(String sql, QueryListener<HRecord>... listeners)

protected 



<T> QueryFuture

HStatementImpl.executeQueryAsync(HBqlStatement statement,
                  Class clazz,
                  QueryListener<T>... listeners)





<T> QueryFuture

HStatementImpl.executeQueryAsync(String sql,
                  Class clazz,
                  QueryListener<T>... listeners)

QueryFuture HStatementImpl.executeQueryAsync(String sql, QueryListener<HRecord>... listeners)

ExecutionResults HPreparedStatementImpl.executeUpdate()

ExecutionResults HStatementImpl.executeUpdate(HBqlStatement statement)

ExecutionResults HStatementImpl.executeUpdate(String sql)

ExecutionResults HConnectionImpl.executeUpdate(String sql)

boolean HConnectionImpl.familyExistsForMapping(String familyName, String mappingName)

boolean HConnectionImpl.familyExistsForTable(String familyName, String tableName)

protected T ResultSetIterator.fetchNextObject()

T ElementMap.findElement(String name)

Set<HMapping> MappingManager.getAllMappings()

Set<HMapping> HConnectionImpl.getAllMappings()

AnnotationResultAccessor HConnectionImpl.getAnnotationMapping(Class<?> clazz)

AnnotationResultAccessor HConnectionImpl.getAnnotationMapping(Object obj)

AsyncExecutorImpl HConnectionImpl.getAsyncExecutorForConnection()

String HRecordImpl.getAttribName(int i)

Set<String> HRecordImpl.getColumnNameList()

ColumnValue HRecordImpl.getColumnValue(String name, boolean inMapping)

Object HRecordImpl.getCurrentValue(String name)

Set<String> HConnectionImpl.getFamilyNames(String tableName)

org.apache.hadoop.hbase.client.HBaseAdmin HConnectionImpl.getHBaseAdmin()

org.apache.hadoop.hbase.HTableDescriptor HConnectionImpl.getHTableDescriptor(String tableName)

org.apache.hadoop.hbase.client.tableindexed.IndexSpecification HConnectionImpl.getIndexForTable(String indexName, String tableName)

org.apache.hadoop.hbase.client.tableindexed.IndexedTableAdmin HConnectionImpl.getIndexTableAdmin()

TableMapping MappingManager.getMapping(String mappingName)

TableMapping HConnectionImpl.getMapping(String mappingName)

protected int HResultSetImpl.getMaxVersions()

protected abstract Iterator<org.apache.hadoop.hbase.client.Result> ResultSetIterator.getNextResultIterator()

static StatementWithParameters HPreparedStatementImpl.getParameterStatement(HBqlStatement statement)

CompletionQueueExecutor HConnectionImpl.getQueryExecutorForConnection()

ResultAccessor HRecordImpl.getResultAccessor()

List<RowRequest> Query.getRowRequestList()

TableMapping HRecordImpl.getTableMapping()

Set<String> HConnectionImpl.getTableNames()

Map<String,byte[]> HRecordImpl.getUnMappedValueMap(String name)

Map<String,NavigableMap<Long,byte[]>> HRecordImpl.getUnMappedVersionMap(String name)

Map<Long,Object> HRecordImpl.getVersionMap(String name)

boolean HConnectionImpl.indexExistsForMapping(String indexName, String mappingName)

boolean HConnectionImpl.indexExistsForTable(String indexName, String tableName)

void AggregateValue.initAggregateValue()

boolean HRecordImpl.isColumnDefined(String name)

boolean HRecordImpl.isCurrentValueSet(ColumnAttrib attrib)

boolean MappingManager.mappingExists(String mappingName)

boolean HConnectionImpl.mappingExists(String mappingName)

static AggregateRecord AggregateRecord.newAggregateRecord(SelectStatement selectStmt)

protected CompletionQueueExecutor QueryExecutorPoolImpl.newElement()

protected HConnectionImpl HConnectionPoolImpl.newElement()

protected abstract T ElementPool.newElement()

HTableWrapper HConnectionImpl.newHTableWrapper(WithArgs withArgs, String tableName)

org.apache.hadoop.hbase.client.tableindexed.IndexedTableDescriptor HConnectionImpl.newIndexedTableDescriptor(String tableName)

static ResultExecutor ResultExecutor.newPooledResultExecutor(QueryExecutorPoolImpl executorPool, int minThreadCount, int maxThreadCount, long keepAliveSecs, int completionQueueSize)

static ResultScannerExecutor ResultScannerExecutor.newPooledResultScannerExecutor(QueryExecutorPoolImpl executorPool, int minThreadCount, int maxThreadCount, long keepAliveSecs, int completionQueueSize)

static



<E> Query<E>

Query.newQuery(HConnectionImpl conn,
         SelectStatement selectStatement,
         Class clazz,
         QueryListener<E>... listeners)

static ResultScannerExecutor ResultScannerExecutor.newResultScannerExecutor(int minThreadCount, int maxThreadCount, long keepAliveSecs, int completionQueueSize)

HResultSet<T> Query.newResultSet(boolean ignoreQueryExecutor)

static HBqlStatement Utils.parseHBqlStatement(String sql)

HPreparedStatement HConnectionImpl.prepareStatement(String sql)

void CompletionQueueExecutor.putElement(T val)

void HPreparedStatementImpl.resetParameters()

void HRecordImpl.setCurrentValue(String name, long timestamp, Object val, boolean inMapping)

void HRecordImpl.setCurrentValue(String name, Object val)

void HRecordImpl.setCurrentValue(String family, String column, long timestamp, Object val)

void ValueMap.setCurrentValueMap(long timestamp, String mapKey, T val)

void HPreparedStatementImpl.setParameter(int i, Object val)

int HPreparedStatementImpl.setParameter(String name, Object val)

void HRecordImpl.setUnMappedCurrentValue(String familyName, String columnName, long timestamp, byte[] val)

void HRecordImpl.setUnMappedVersionMap(String familyName, String columnName, NavigableMap<Long,byte[]> val)

void ValueMap.setVersionMap(String name, NavigableMap<Long,T> val)

void HRecordImpl.setVersionValue(String familyName, String columnName, long timestamp, Object val, boolean inMapping)

boolean HConnectionImpl.tableAvailable(String tableName)

boolean HConnectionImpl.tableEnabled(String tableName)

boolean HConnectionImpl.tableExists(String tableName)

protected T ElementPool.take()

HConnection HConnectionPoolImpl.takeConnection()

CompletionQueue.Element<T> CompletionQueueExecutor.takeElement()

void HConnectionImpl.validateAsyncExecutorNameExists(String name)

void HConnectionImpl.validateFamilyExistsForTable(String familyName, String tableName)

void HConnectionImpl.validateIndexExistsForTable(String indexName, String tableName)

void MappingManager.validatePersistentMetadata()

void HConnectionImpl.validateQueryExecutorPoolNameExists(String poolName)

void HConnectionImpl.validateTableDisabled(String tableName, String action)

void HConnectionImpl.validateTableName(String tableName)

Constructors in org.apache.hadoop.hbase.hbql.impl that throw HBqlException
`CompletionQueueExecutor(QueryExecutorPoolImpl executorPool, int minThreadCount, int maxThreadCount, long keepAliveSecs, int completionQueueSize)`
`HConnectionImpl(org.apache.hadoop.conf.Configuration configuration, HConnectionPoolImpl connectionPool, int maxTablePoolReferencesPerTable)`
`HConnectionPoolImpl(int initPoolSize, int maxPoolSize, String poolName, org.apache.hadoop.conf.Configuration configuration, int maxPoolReferencesPerTablePerConnection)`
`HPreparedStatementImpl(HConnectionImpl hbqlConnection, String sql)`
`HResultSetImpl(Query<T> query, CompletionQueueExecutor<R> completionQueueExecutor)`
`ResultScannerExecutor(QueryExecutorPoolImpl executorPool, int minThreadCount, int maxThreadCount, long keepAliveSecs, int completionQueueSize)`
`ResultSetIterator(HResultSetImpl<T,R> resultSet)`
`ValueMap(String name)`

Uses of HBqlException in org.apache.hadoop.hbase.hbql.index

Methods in org.apache.hadoop.hbase.hbql.index that throw HBqlException
`static SingleColumnIndex`	`SingleColumnIndex.newIndex(String indexName, List<String> indexList, List<String> includeList)`

Uses of HBqlException in org.apache.hadoop.hbase.hbql.io

Methods in org.apache.hadoop.hbase.hbql.io that throw HBqlException
`abstract byte[]`	`Serialization.getArrayAsBytes(FieldType fieldType, Object obj)`
`byte[]`	`JavaSerialization.getArrayAsBytes(FieldType fieldType, Object obj)`
`byte[]`	`HadoopSerialization.getArrayAsBytes(FieldType fieldType, Object obj)`
`abstract Object`	`Serialization.getArrayFromBytes(FieldType fieldType, Class clazz, byte[] b)`
`Object`	`JavaSerialization.getArrayFromBytes(FieldType fieldType, Class clazz, byte[] b)`
`Object`	`HadoopSerialization.getArrayFromBytes(FieldType fieldType, Class clazz, byte[] b)`
`Boolean`	`Serialization.getBooleanFromBytes(byte[] b)`
`Byte`	`Serialization.getByteFromBytes(byte[] b)`
`byte[]`	`Serialization.getNumberEqualityBytes(FieldType fieldType, Number val)`
`Number`	`Serialization.getNumberFromBytes(FieldType fieldType, byte[] b)`
`byte[]`	`Serialization.getObjectAsBytes(Object obj)`
`Object`	`Serialization.getObjectFromBytes(byte[] b)`
`abstract byte[]`	`Serialization.getScalarAsBytes(FieldType fieldType, Object obj)`
`byte[]`	`JavaSerialization.getScalarAsBytes(FieldType fieldType, Object obj)`
`byte[]`	`HadoopSerialization.getScalarAsBytes(FieldType fieldType, Object obj)`
`abstract Object`	`Serialization.getScalarFromBytes(FieldType fieldType, byte[] b)`
`Object`	`JavaSerialization.getScalarFromBytes(FieldType fieldType, byte[] b)`
`Object`	`HadoopSerialization.getScalarFromBytes(FieldType fieldType, byte[] b)`
`byte[]`	`Serialization.getStringAsBytes(String obj)`
`String`	`Serialization.getStringFromBytes(byte[] b)`

Uses of HBqlException in org.apache.hadoop.hbase.hbql.mapping

Methods in org.apache.hadoop.hbase.hbql.mapping that throw HBqlException
`void`	`TableMapping.addAttribToFamilyNameColumnListMap(HRecordAttrib attrib)`
`void`	`TableMapping.addAttribToFamilyNameColumnListMap(String familyName, List<HRecordAttrib> attribList)`
`protected void`	`TableMapping.addAttribToFamilyQualifiedNameMap(HRecordAttrib attrib)`
`protected void`	`Mapping.addAttribToVariableNameMap(ColumnAttrib attrib, String... attribNames)`
`protected void`	`TableMapping.addVersionAttrib(HRecordAttrib attrib)`
`String`	`TableMapping.asString()`
`String`	`HRecordAttrib.asString()`
`protected void`	`ColumnAttrib.defineAccessors()`
`void`	`TableMapping.dropMapping()`
`org.apache.hadoop.hbase.regionserver.StoreFile.BloomType`	`BloomFilterTypeProperty.getBloomValue()`
`abstract ColumnAttrib`	`ResultAccessor.getColumnAttribByName(String name)`
`ColumnAttrib`	`HRecordResultAccessor.getColumnAttribByName(String name)`
`ColumnAttrib`	`AnnotationResultAccessor.getColumnAttribByName(String name)`
`abstract ColumnAttrib`	`ResultAccessor.getColumnAttribByQualifiedName(String familyName, String columnName)`
`ColumnAttrib`	`HRecordResultAccessor.getColumnAttribByQualifiedName(String familyName, String columnName)`
`ColumnAttrib`	`AnnotationResultAccessor.getColumnAttribByQualifiedName(String familyName, String columnName)`
`org.apache.hadoop.hbase.HColumnDescriptor`	`FamilyDefinition.getColumnDescription()`
`byte[]`	`ColumnAttrib.getColumnNameAsBytes()`
`protected Class`	`SelectFamilyAttrib.getComponentType()`
`protected abstract Class`	`ColumnAttrib.getComponentType()`
`org.apache.hadoop.hbase.io.hfile.Compression.Algorithm`	`CompressionTypeProperty.getCompressionValue()`
`Object`	`SelectFamilyAttrib.getCurrentValue(Object obj)`
`Object`	`HRecordAttrib.getCurrentValue(Object record)`
`Object`	`FieldAttrib.getCurrentValue(Object obj)`
`abstract Object`	`ColumnAttrib.getCurrentValue(Object obj)`
`Object`	`FieldAttrib.getDefaultValue()`
`Object`	`CurrentValueAnnotationAttrib.getDefaultValue()`
`Object`	`ColumnAttrib.getDefaultValue()`
`byte[]`	`ColumnAttrib.getFamilyNameAsBytes()`
`byte[]`	`ColumnAttrib.getFamilyQualifiedNameAsBytes()`
`static FieldType`	`FieldType.getFieldType(String desc)`
`ColumnAttrib`	`ResultAccessor.getKeyAttrib()`
`ColumnAttrib`	`AnnotationResultAccessor.getKeyAttrib()`
`Set<String>`	`TableMapping.getMappingFamilyNames()`
`abstract Collection<String>`	`Mapping.getMappingFamilyNames()`
`protected Method`	`HRecordAttrib.getMethod(String methodName, Class<?>... params)`
`protected abstract Method`	`ColumnAttrib.getMethod(String methodName, Class<?>... params)`
`TableMapping`	`ResultAccessor.getTableMapping()`
`byte[]`	`TableMapping.getTableNameAsBytes()`
`byte[]`	`ColumnAttrib.getValueAsBytes(Object obj)`
`Object`	`ColumnAttrib.getValueFromBytes(Object obj, byte[] b)`
`Object`	`ColumnAttrib.getValueFromBytes(org.apache.hadoop.hbase.client.Result result)`
`abstract ColumnAttrib`	`ResultAccessor.getVersionAttrib(String name)`
`ColumnAttrib`	`HRecordResultAccessor.getVersionAttrib(String name)`
`ColumnAttrib`	`ResultAccessor.getVersionAttrib(String familyName, String columnName)`
`Map<Long,Object>`	`SelectFamilyAttrib.getVersionMap(Object recordObj)`
`Map<Long,Object>`	`HRecordAttrib.getVersionMap(Object record)`
`Map<Long,Object>`	`FieldAttrib.getVersionMap(Object obj)`
`abstract Map<Long,Object>`	`ColumnAttrib.getVersionMap(Object obj)`
`boolean`	`FieldAttrib.hasDefaultArg()`
`boolean`	`CurrentValueAnnotationAttrib.hasDefaultArg()`
`boolean`	`ColumnAttrib.hasDefaultArg()`
`byte[]`	`ColumnAttrib.invokeGetterMethod(Object obj)`
`Object`	`ColumnAttrib.invokeSetterMethod(Object obj, byte[] b)`
`static AnnotationResultAccessor`	`AnnotationResultAccessor.newAnnotationMapping(HConnectionImpl conn, Class<?> clazz)`
`HRecord`	`TableMapping.newHRecord()`
`HRecord`	`TableMapping.newHRecord(Map<String,Object> initMap)`
`abstract Object`	`ResultAccessor.newObject(HConnectionImpl conn, MappingContext mappingContext, List<SelectElement> selectElementList, int maxVersions, org.apache.hadoop.hbase.client.Result result)`
`Object`	`HRecordResultAccessor.newObject(HConnectionImpl conn, MappingContext mappingContext, List<SelectElement> selectElementList, int maxVersions, org.apache.hadoop.hbase.client.Result result)`
`Object`	`AnnotationResultAccessor.newObject(HConnectionImpl conn, MappingContext mappingContext, List<SelectElement> selectElementList, int maxVersions, org.apache.hadoop.hbase.client.Result result)`
`RecordFilter`	`TableMapping.newRecordFilter(String query)`
`void`	`ColumnAttrib.resetDefaultValue()`
`void`	`Mapping.resetDefaultValues()`
`void`	`ColumnAttrib.setCurrentValue(Object obj, long timestamp, byte[] b)`
`void`	`SelectFamilyAttrib.setCurrentValue(Object obj, long timestamp, Object val)`
`void`	`HRecordAttrib.setCurrentValue(Object record, long timestamp, Object val)`
`abstract void`	`ColumnAttrib.setCurrentValue(Object obj, long timestamp, Object val)`
`void`	`SelectFamilyAttrib.setUnMappedCurrentValue(Object obj, String name, byte[] value)`
`void`	`HRecordAttrib.setUnMappedCurrentValue(Object record, String name, byte[] value)`
`void`	`FieldAttrib.setUnMappedCurrentValue(Object obj, String name, byte[] val)`
`abstract void`	`ColumnAttrib.setUnMappedCurrentValue(Object obj, String name, byte[] value)`
`void`	`SelectFamilyAttrib.setUnMappedVersionMap(Object obj, String name, NavigableMap<Long,byte[]> timeStampMap)`
`void`	`HRecordAttrib.setUnMappedVersionMap(Object record, String name, NavigableMap<Long,byte[]> timeStampMap)`
`void`	`FieldAttrib.setUnMappedVersionMap(Object obj, String name, NavigableMap<Long,byte[]> timeStampMap)`
`abstract void`	`ColumnAttrib.setUnMappedVersionMap(Object obj, String name, NavigableMap<Long,byte[]> timeStampMap)`
`void`	`ColumnAttrib.setVersionMap(Object obj, NavigableMap<Long,byte[]> timeStampMap)`
`void`	`FamilyMapping.validate()`
`void`	`TableMapping.validate(String mappingName)`
`void`	`TableMapping.validateKeyInfo(String indexName)`
`void`	`MappingContext.validateMappingName(HConnectionImpl conn)`
`void`	`ColumnAttrib.validateValueWidth(Object value)`

Constructors in org.apache.hadoop.hbase.hbql.mapping that throw HBqlException
`CurrentValueAnnotationAttrib(Field field, ColumnAttrib columnAttrib)`
`HRecordAttrib(ColumnDefinition columnDefinition)`
`SelectFamilyAttrib(String familyName)`
`TableMapping(HConnectionImpl conn, boolean tempMapping, boolean systemMapping, String mappingName, String tableName, KeyInfo keyInfo, List<FamilyMapping> familyMappingList)`
`VersionAnnotationAttrib(String familyName, String columnName, Field field, FieldType fieldType, String getter, String setter)`

Uses of HBqlException in org.apache.hadoop.hbase.hbql.parser

Methods in org.apache.hadoop.hbase.hbql.parser that throw HBqlException
`static Object`	`ParserUtil.evaluateSelectElement(SelectExpressionContext elem)`
`static ExpressionTree`	`ParserUtil.getExpressionTree(String str, MappingContext mappingContext)`
`static List<HBqlStatement>`	`ParserUtil.parseConsoleStatements(String sql)`
`static Object`	`ParserUtil.parseExpression(String sql)`
`static HBqlStatement`	`ParserUtil.parseHBqlStatement(String sql)`
`static SelectExpressionContext`	`ParserUtil.parseSelectElement(String sql)`
`static ExpressionTree`	`ParserUtil.parseWhereExpression(String sql, MappingContext mappingContext)`

Uses of HBqlException in org.apache.hadoop.hbase.hbql.statement

Methods in org.apache.hadoop.hbase.hbql.statement that throw HBqlException
`void`	`SelectStatement.determineIfAggregateQuery()`
`boolean`	`StatementPredicate.evaluate(HConnectionImpl conn)`
`ExecutionResults`	`GenericStatement.evaluatePredicateAndExecute(HConnectionImpl conn)`
`ExecutionResults`	`ConnectionStatement.evaluatePredicateAndExecute(HConnectionImpl connection)`
`ExecutionResults`	`SetStatement.execute()`
`ExecutionResults`	`NonConnectionStatement.execute()`
`protected ExecutionResults`	`SplitTableStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`ShowTablesStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`ShowQueryExecutorPoolsStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`ShowMappingsStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`ShowAsyncExecutorsStatement.execute(HConnectionImpl conn)`
`ExecutionResults`	`ParseStatement.execute(HConnectionImpl connection)`
`protected ExecutionResults`	`InsertStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`GenericStatement.execute(HConnectionImpl connection)`
`protected ExecutionResults`	`FlushTableStatement.execute(HConnectionImpl conn)`
`ExecutionResults`	`EvalStatement.execute(HConnectionImpl connection)`
`protected ExecutionResults`	`EnableTableStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`DropTableStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`DropQueryExecutorPoolStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`DropMappingStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`DropIndexForTableStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`DropIndexForMappingStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`DropAsyncExecutorStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`DisableTableStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`DescribeTableStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`DescribeMappingStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`DescribeIndexForTableStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`DescribeIndexForMappingStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`DeleteStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`CreateTableStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`CreateQueryExecutorPoolStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`CreateMappingStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`CreateIndexStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`CreateAsyncExecutorStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`CompactTableStatement.execute(HConnectionImpl conn)`
`protected ExecutionResults`	`AlterTableStatement.execute(HConnectionImpl conn)`
`void`	`DropFamilyAction.execute(HConnectionImpl conn, org.apache.hadoop.hbase.client.HBaseAdmin admin, String tableName)`
`void`	`AlterTableAction.execute(HConnectionImpl connection, org.apache.hadoop.hbase.client.HBaseAdmin admin, String tableName)`
`void`	`AlterFamilyAction.execute(HConnectionImpl conn, org.apache.hadoop.hbase.client.HBaseAdmin admin, String tableName)`
`void`	`AddFamilyAction.execute(HConnectionImpl conn, org.apache.hadoop.hbase.client.HBaseAdmin admin, String tableName)`
`NamedParameter`	`NamedParameters.getParameter(int i)`
`abstract int`	`StatementWithParameters.setStatementParameter(String name, Object val)`
`int`	`SelectStatement.setStatementParameter(String name, Object val)`
`int`	`InsertStatement.setStatementParameter(String name, Object val)`
`int`	`DeleteStatement.setStatementParameter(String name, Object val)`
`void`	`HBqlStatement.validate()`
`void`	`GenericStatement.validate()`
`void`	`CreateMappingStatement.validate()`
`abstract void`	`StatementWithParameters.validate(HConnectionImpl connection)`
`void`	`SelectStatement.validate(HConnectionImpl conn)`
`void`	`InsertStatement.validate(HConnectionImpl conn)`
`void`	`DeleteStatement.validate(HConnectionImpl conn)`
`abstract void`	`StatementWithParameters.validateTypes()`
`void`	`SelectStatement.validateTypes()`
`void`	`InsertStatement.validateTypes()`
`void`	`DeleteStatement.validateTypes()`

Uses of HBqlException in org.apache.hadoop.hbase.hbql.statement.args

Methods in org.apache.hadoop.hbase.hbql.statement.args that throw HBqlException
`void`	`SelectValuesInsertSource.execute()`
`abstract void`	`InsertValueSource.execute()`
`Object`	`DefaultArg.getDefaultValue()`
`org.apache.hadoop.hbase.filter.Filter`	`WithArgs.getFilterForTableIndex()`
`long`	`WithArgs.getLimit()`
`int`	`WithArgs.getMaxVersions()`
`int`	`VersionArgs.getMaxVersions()`
`List<RowRequest>`	`WithArgs.getRowRequestList(HConnectionImpl conn, Mapping mapping, Set<ColumnAttrib> columnAttribs)`
`List<RowRequest>`	`KeyRange.getRowRequestList(WithArgs withArgs, ColumnAttrib keyAttrib, Set<ColumnAttrib> columnAttribs)`
`long`	`LimitArgs.getValue()`
`Object`	`SingleRowInsertSource.getValue(HConnectionImpl conn, int i)`
`Object`	`SelectValuesInsertSource.getValue(HConnectionImpl conn, int i)`
`abstract Object`	`InsertValueSource.getValue(HConnectionImpl conn, int i)`
`List<Class<? extends GenericValue>>`	`SingleRowInsertSource.getValuesTypeList()`
`List<Class<? extends GenericValue>>`	`SelectValuesInsertSource.getValuesTypeList()`
`abstract List<Class<? extends GenericValue>>`	`InsertValueSource.getValuesTypeList()`
`boolean`	`SingleRowInsertSource.isDefaultValue(int i)`
`boolean`	`SelectValuesInsertSource.isDefaultValue(int i)`
`abstract boolean`	`InsertValueSource.isDefaultValue(int i)`
`void`	`WithArgs.setGetArgs(org.apache.hadoop.hbase.client.Get get, Set<ColumnAttrib> columnAttribs)`
`int`	`SingleRowInsertSource.setInsertSourceParameter(String name, Object val)`
`int`	`SelectValuesInsertSource.setInsertSourceParameter(String name, Object val)`
`abstract int`	`InsertValueSource.setInsertSourceParameter(String name, Object val)`
`void`	`WithArgs.setMappingContext(MappingContext mappingContext)`
`void`	`KeyRangeArgs.setMappingContext(MappingContext mappingContext)`
`void`	`VersionArgs.setMaxVersions(org.apache.hadoop.hbase.client.Get get)`
`void`	`VersionArgs.setMaxVersions(org.apache.hadoop.hbase.client.Scan scan)`
`int`	`WithArgs.setParameter(String name, Object val)`
`int`	`KeyRangeArgs.setParameter(String name, Object val)`
`void`	`WithArgs.setScanArgs(org.apache.hadoop.hbase.client.Scan scan, Set<ColumnAttrib> columnAttribs)`
`void`	`ScannerCacheArgs.setScannerCacheSize(org.apache.hadoop.hbase.client.Scan scan)`
`void`	`TimestampArgs.setTimeStamp(org.apache.hadoop.hbase.client.Get get)`
`void`	`TimestampArgs.setTimeStamp(org.apache.hadoop.hbase.client.Scan scan)`
`void`	`SingleRowInsertSource.validate()`
`void`	`SelectValuesInsertSource.validate()`
`void`	`KeyRangeArgs.validate()`
`void`	`KeyRange.validate()`
`abstract void`	`InsertValueSource.validate()`
`void`	`ColumnWidth.validate()`
`void`	`WithArgs.validate(HConnectionImpl conn, TableMapping mapping)`
`void`	`WithArgs.validateArgTypes()`

Constructors in org.apache.hadoop.hbase.hbql.statement.args that throw HBqlException
`DefaultArg(Class<? extends GenericValue> exprType, GenericValue expr)`

Uses of HBqlException in org.apache.hadoop.hbase.hbql.statement.select

Methods in org.apache.hadoop.hbase.hbql.statement.select that throw HBqlException
`void`	`SelectExpressionContext.applyResultToAggregateValue(AggregateValue aggregateValue, org.apache.hadoop.hbase.client.Result result)`
`void`	`SelectExpressionContext.assignSelectValue(HConnectionImpl conn, Object obj, int maxVerions, org.apache.hadoop.hbase.client.Result result)`
`void`	`SelectElement.assignSelectValue(HConnectionImpl connection, Object newobj, int maxVerions, org.apache.hadoop.hbase.client.Result result)`
`void`	`FamilySelectElement.assignSelectValue(HConnectionImpl conn, Object obj, int maxVersions, org.apache.hadoop.hbase.client.Result result)`
`Class<? extends GenericValue>`	`SelectExpressionContext.getExpressionType()`
`org.apache.hadoop.hbase.client.ResultScanner`	`ScanRequest.getResultScanner(Mapping mapping, WithArgs withArgs, org.apache.hadoop.hbase.client.HTableInterface table)`
`org.apache.hadoop.hbase.client.ResultScanner`	`RowRequest.getResultScanner(Mapping mapping, WithArgs withArgs, org.apache.hadoop.hbase.client.HTableInterface table)`
`org.apache.hadoop.hbase.client.ResultScanner`	`IndexRequest.getResultScanner(Mapping mapping, WithArgs withArgs, org.apache.hadoop.hbase.client.HTableInterface table)`
`org.apache.hadoop.hbase.client.ResultScanner`	`GetRequest.getResultScanner(Mapping mapping, WithArgs withArgs, org.apache.hadoop.hbase.client.HTableInterface table)`
`protected TableMapping`	`FamilySelectElement.getTableMapping()`
`Object`	`SimpleExpressionContext.getValue(HConnectionImpl conn)`
`Object`	`SelectExpressionContext.getValue(HConnectionImpl conn, org.apache.hadoop.hbase.client.Result result)`
`void`	`SelectExpressionContext.initAggregateValue(AggregateValue aggregateValue)`
`AggregateValue`	`SelectExpressionContext.newAggregateValue()`
`AggregateValue`	`SelectElement.newAggregateValue()`
`AggregateValue`	`FamilySelectElement.newAggregateValue()`
`int`	`SelectElement.setParameter(String name, Object val)`
`void`	`SimpleExpressionContext.validate()`
`void`	`SelectExpressionContext.validate(MappingContext mappingContext, HConnection connection)`
`void`	`SelectElement.validate(MappingContext mappingContext, HConnection connection)`
`void`	`FamilySelectElement.validate(MappingContext mappingContext, HConnection connection)`
`void`	`SelectElement.validateTypes(boolean allowColumns, boolean allowCollections)`
`void`	`FamilySelectElement.validateTypes(boolean allowColumns, boolean allowCollections)`

Uses of HBqlException in org.apache.hadoop.hbase.hbql.util

Methods in org.apache.hadoop.hbase.hbql.util that throw HBqlException
`void`	`CompletionQueue.putElement(T val)`
`CompletionQueue.Element<T>`	`CompletionQueue.takeElement()`

Constructors in org.apache.hadoop.hbase.hbql.util that throw HBqlException
`CompletionQueue(int size)`

Uses of HBqlException in org.apache.hadoop.hbase.jdbc

Constructors in org.apache.hadoop.hbase.jdbc that throw HBqlException
`ConnectionPool(int initPoolSize, int maxConnectionPoolSize)`
`ConnectionPool(int initConnectionPoolSize, int maxConnectionPoolSize, org.apache.hadoop.hbase.HBaseConfiguration config)`
`ConnectionPool(int initPoolSize, int maxConnectionPoolSize, String connectionPoolName)`
`ConnectionPool(int initPoolSize, int maxConnectionPoolSize, String poolName, org.apache.hadoop.hbase.HBaseConfiguration config)`

Uses of HBqlException in org.apache.hadoop.hbase.jdbc.impl

Methods in org.apache.hadoop.hbase.jdbc.impl that throw HBqlException
`void`	`PreparedStatementImpl.clearParameters()`
`void`	`PreparedStatementImpl.setBoolean(int i, boolean b)`
`void`	`PreparedStatementImpl.setByte(int i, byte b)`
`void`	`PreparedStatementImpl.setBytes(int i, byte[] bytes)`
`void`	`PreparedStatementImpl.setDate(int i, Date date)`
`void`	`PreparedStatementImpl.setDouble(int i, double v)`
`void`	`PreparedStatementImpl.setFloat(int i, float v)`
`void`	`PreparedStatementImpl.setInt(int i, int i1)`
`void`	`PreparedStatementImpl.setLong(int i, long l)`
`void`	`PreparedStatementImpl.setNull(int i, int i1)`
`void`	`PreparedStatementImpl.setObject(int i, Object o)`
`void`	`PreparedStatementImpl.setShort(int i, short i2)`
`void`	`PreparedStatementImpl.setString(int i, String s)`

Constructors in org.apache.hadoop.hbase.jdbc.impl that throw HBqlException
`ConnectionImpl(org.apache.hadoop.conf.Configuration config, int maxPoolReferencesPerTable)`
`PreparedStatementImpl(ConnectionImpl connectionImpl, String sql)`

Uses of HBqlException in org.apache.yaoql.client

Methods in org.apache.yaoql.client that throw HBqlException
`List<T>`	`ObjectQuery.getResultList(Collection<T> objs)`
`ObjectResultSet<T>`	`ObjectQuery.getResults(Collection<T> objs)`

Constructors in org.apache.yaoql.client that throw HBqlException
`ObjectResultSet(ObjectQueryImpl<T> objectQuery, Collection<T> objects)`

Uses of HBqlException in org.apache.yaoql.impl

Methods in org.apache.yaoql.impl that throw HBqlException
`protected void`	`ParameterBinding.applyParameters(ExpressionTree expressionTree)`
`ColumnAttrib`	`ReflectionResultAccessor.getColumnAttribByName(String name)`
`ColumnAttrib`	`ReflectionResultAccessor.getColumnAttribByQualifiedName(String familyName, String columnName)`
`ExpressionTree`	`ObjectQueryImpl.getExpressionTree(Collection<T> objects)`
`Collection<String>`	`ReflectionMapping.getMappingFamilyNames()`
`List<T>`	`ObjectQueryImpl.getResultList(Collection<T> objs)`
`ObjectResultSet<T>`	`ObjectQueryImpl.getResults(Collection<T> objs)`
`ColumnAttrib`	`ReflectionResultAccessor.getVersionAttrib(String name)`
`Object`	`ReflectionResultAccessor.newObject(HConnectionImpl conn, MappingContext mappingContext, List<SelectElement> selectElementList, int maxVersions, org.apache.hadoop.hbase.client.Result result)`