MetastoreResource (Lens 2.7.1 API)

java.lang.Object
- org.apache.lens.server.metastore.MetastoreResource

@Path(value="metastore")
 @Produces(value={"application/xml","application/json"})
public class MetastoreResource
extends Object

metastore resource api

This provides api for all things metastore.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class MetastoreResource.Entity

Nested Classes
Modifier and Type	Class and Description
`static class`	`MetastoreResource.Entity`

Field Summary

Fields
Modifier and Type Field and Description

static ObjectFactory X_CUBE_OBJECT_FACTORY

Fields
Modifier and Type	Field and Description
`static ObjectFactory`	`X_CUBE_OBJECT_FACTORY`

Constructor Summary

Constructors
Constructor and Description

MetastoreResource()

Constructors
Constructor and Description
`MetastoreResource()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`APIResult`	`addPartitionsToDimStorage(LensSessionHandle sessionid, String dimTableName, String storage, XPartitionList partitions)` Add new partitions for a storage of dimension
`APIResult`	`addPartitionsToFactStorage(LensSessionHandle sessionid, String factName, String storage, XPartitionList partitions)` Batch Add partitions for a storage of fact
`APIResult`	`addPartitionToDimStorage(LensSessionHandle sessionid, String dimTableName, String storage, XPartition partition)` Add a new partition for a storage of dimension
`APIResult`	`addPartitionToFactStorage(LensSessionHandle sessionid, String factName, String storage, XPartition partition)` Add a new partition for a storage of fact
`APIResult`	`addStorageToFact(LensSessionHandle sessionid, String factName, XStorageTableElement storageTable)` Add storage to fact table
`APIResult`	`createDatabase(LensSessionHandle sessionid, boolean ignoreIfExisting, String dbName)` Create a new database
`APIResult`	`createDimension(LensSessionHandle sessionid, XDimension dimension)` Create new dimension
`APIResult`	`createDimensionStorage(LensSessionHandle sessionid, String dimTableName, XStorageTableElement storageTbl)` Add storage to dimension table
`APIResult`	`createDimensionTable(LensSessionHandle sessionid, XDimensionTable dimensionTable)` Create a new dimension table
`APIResult`	`createFactTable(LensSessionHandle sessionid, XFact fact)` Create a new fact tabble
`APIResult`	`createNewCube(LensSessionHandle sessionid, XCube cube)` Create a new cube
`APIResult`	`createNewStorage(LensSessionHandle sessionid, XStorage storage)` Create new storage
`APIResult`	`createSegmentation(LensSessionHandle sessionid, XSegmentation seg)` Create a new segmentation
`APIResult`	`deleteAllCubes(LensSessionHandle sessionid)` Delete all cubes
`APIResult`	`deleteAllDimensions(LensSessionHandle sessionid)` Delete all dimensions in metastore
`APIResult`	`deleteAllFacts(LensSessionHandle sessionid, boolean cascade)` Delete all fact tables
`APIResult`	`deleteAllSegmentations(LensSessionHandle sessionid)` Delete all segmentations
`APIResult`	`deleteAllStorages(LensSessionHandle sessionid)` Delete all storages in metastore
`APIResult`	`dropAllStoragesOfDim(LensSessionHandle sessionid, String dimTableName)` Drop all the storage tables of a dimension table
`APIResult`	`dropAllStoragesOfFact(LensSessionHandle sessionid, String factName)` Drop all the storage tables of a fact table
`APIResult`	`dropCube(LensSessionHandle sessionid, String cubeName)` Drop the cube, specified by name
`APIResult`	`dropDatabase(LensSessionHandle sessionid, String dbName, boolean cascade)` Delete the db specified by name.
`APIResult`	`dropDimension(LensSessionHandle sessionid, String dimName)` Drop the dimension, specified by name
`APIResult`	`dropDimensionTable(LensSessionHandle sessionid, String dimension, boolean cascade)` Drop the dimension table, specified by name
`APIResult`	`dropFactTable(LensSessionHandle sessionid, String factName, boolean cascade)` Drop the fact table, specified by name
`APIResult`	`dropPartitionOfFactStorageByValues(LensSessionHandle sessionid, String factName, String storage, String values)` Drop the partitions in the storage of a fact table, specified by exact values
`APIResult`	`dropPartitionsOfDimStorageByFilter(LensSessionHandle sessionid, String dimTableName, String storage, String filter)` Drop the partitions in the storage of a dimension table; can specified filter as well
`APIResult`	`dropPartitionsOfDimStorageByValue(LensSessionHandle sessionid, String dimTableName, String storage, String values)` Drop the partitions in the storage of a dimension table, specified by exact values
`APIResult`	`dropPartitionsOfFactStorageByFilter(LensSessionHandle sessionid, String factName, String storage, String filter)` Drop the partitions in the storage of a fact; can specified filter as well
`APIResult`	`dropSegmentation(LensSessionHandle sessionid, String segmentationName)` Drop the segmentation, specified by name
`APIResult`	`dropStorage(LensSessionHandle sessionid, String storageName)` Drop the storage, specified by name
`APIResult`	`dropStorageFromFact(LensSessionHandle sessionid, String factName, String storage)` Drop the storage of a fact, specified by name
`APIResult`	`dropStorageOfDim(LensSessionHandle sessionid, String dimTableName, String storage)` Drop the storage of a dimension table, specified by name
`StringList`	`getAllCubes(LensSessionHandle sessionid, String cubeTypes)` Get all cubes in the metastores, of the specified type
`StringList`	`getAllDatabases(LensSessionHandle sessionid)` Get all databases in the metastore
`StringList`	`getAllDimensionNames(LensSessionHandle sessionid)` Get all dimensions in the metastore
`StringList`	`getAllDimensionTablesOfDimension(LensSessionHandle sessionid, String dimensionName)` Get all dimtables that belong to a dimension in the metastore
`StringList`	`getAllDims(LensSessionHandle sessionid)` Get all dimension tables in the metastore
`StringList`	`getAllFacts(LensSessionHandle sessionid)` Get all fact tables in the metastore in the current database
`StringList`	`getAllFactsOfCube(LensSessionHandle sessionid, String cubeName)` Get all facts that belong to a cube in the metastore
`JAXBElement<XJoinChains>`	`getAllJoinChains(LensSessionHandle sessionid, String tableName)` Get all chains that belong to a table(cube or dimension) in the metastore
`StringList`	`getAllNativeTables(LensSessionHandle sessionid, String dbOption, String dbName)` Get all native tables.
`JAXBElement<XPartitionList>`	`getAllPartitionsOfDimStorage(LensSessionHandle sessionid, String dimension, String storage, String filter)` Get all partition of the dimension table in the specified storage; can be filtered
`JAXBElement<XPartitionList>`	`getAllPartitionsOfFactStorageByFilter(LensSessionHandle sessionid, String factName, String storage, String filter)` Get all partitions of the fact table in the specified storage; can be filtered as well.
`StringList`	`getAllSegmentations(LensSessionHandle sessionid)` Get all segmentations in the current database
`StringList`	`getAllSegmentationsOfCube(LensSessionHandle sessionid, String cubeName)` Get all segmentations that belong to a cube in the metastore
`StringList`	`getAllStorages(LensSessionHandle sessionid)` Get all storages in the metastore
`JAXBElement<XCube>`	`getCube(LensSessionHandle sessionid, String cubeName)` Get the cube specified by name
`String`	`getDatabase(LensSessionHandle sessionid)` Get the current database
`JAXBElement<XDimension>`	`getDimension(LensSessionHandle sessionid, String dimName)` Get the dimension specified by name
`StringList`	`getDimensionStorages(LensSessionHandle sessionid, String dimension)` Get all storages of the dimension table in the metastore
`JAXBElement<XDimensionTable>`	`getDimensionTable(LensSessionHandle sessionid, String dimTableName)` Get the dimension table specified by name
`JAXBElement<XFact>`	`getFactTable(LensSessionHandle sessionid, String factName)` Get the fact table specified by name
`JAXBElement<XFlattenedColumns>`	`getFlattenedColumns(LensSessionHandle sessionid, String tableName, boolean addChains)` Get flattened list of columns reachable from a cube or a dimension
`DateTime`	`getLatestDateOfCube(LensSessionHandle sessionid, String cubeName, String timeDimension)` Get the latest available date upto which data is available for the base cubes, for the time dimension.
`String`	`getMessage()` API to know if metastore service is up and running
`JAXBElement<XNativeTable>`	`getNativeTable(LensSessionHandle sessionid, String tableName)` Get the native table passed in name
`StringList`	`getPartitionTimelines(LensSessionHandle sessionid, String factName, String storage, String updatePeriod, String timeDimension)` Get the partition timelines.
`JAXBElement<XSegmentation>`	`getSegmentation(LensSessionHandle sessionid, String segmentationName)` Get the segmentation specified by name
`JAXBElement<XStorage>`	`getStorage(LensSessionHandle sessionid, String storageName)` Get the storage specified by name
`JAXBElement<XStorageTableElement>`	`getStorageOfDim(LensSessionHandle sessionid, String dimTableName, String storage)` Get the dim storage table
`JAXBElement<XStorageTableElement>`	`getStorageOfFact(LensSessionHandle sessionid, String factName, String storage)` Get the fact storage table
`StringList`	`getStoragesOfFact(LensSessionHandle sessionid, String factName)` Get all storages of the fact table in the metastore
`static CubeMetastoreService`	`getSvc()`
`APIResult`	`setDatabase(LensSessionHandle sessionid, String dbName)` Set the current db
`APIResult`	`updateCube(LensSessionHandle sessionid, String cubeName, XCube cube)` Update cube definition
`APIResult`	`updateCubeDimension(LensSessionHandle sessionid, String dimTableName, XDimensionTable dimensionTable)` Update dimension table definition
`APIResult`	`updateDimension(LensSessionHandle sessionid, String dimName, XDimension dimension)` Update dimension definition
`APIResult`	`updateFactTable(LensSessionHandle sessionid, String factName, XFact fact)` Update fact table definition
`APIResult`	`updatePartitionOfDimStorage(LensSessionHandle sessionid, String dimTableName, String storage, XPartition partition)` Updates an existing partition for a storage of dimension
`APIResult`	`updatePartitionOfFactStorage(LensSessionHandle sessionid, String factName, String storage, XPartition partition)` updates an existing partition for a storage of fact
`APIResult`	`updatePartitionsOfDimStorage(LensSessionHandle sessionid, String dimTableName, String storage, XPartitionList partitions)` Add new partitions for a storage of dimension
`APIResult`	`updatePartitionsOfFactStorage(LensSessionHandle sessionid, String factName, String storage, XPartitionList partitions)` Batch Update partitions for a storage of fact
`APIResult`	`updateSegmentation(LensSessionHandle sessionid, String segmentationName, XSegmentation seg)` Update segmentation
`APIResult`	`updateStorage(LensSessionHandle sessionid, String storageName, XStorage storage)` Update storage definition

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

X_CUBE_OBJECT_FACTORY

public static final ObjectFactory X_CUBE_OBJECT_FACTORY

Constructor Detail
- MetastoreResource
```
public MetastoreResource()
```

Method Detail

getSvc

public static CubeMetastoreService getSvc()

getMessage
```
@GET
 @Produces(value="text/plain")
public String getMessage()
```
API to know if metastore service is up and running

Returns:

Simple text saying it up

getAllDatabases

@GET
 @Path(value="databases")
public StringList getAllDatabases(@QueryParam(value="sessionid")
                                                                 LensSessionHandle sessionid)
                                                          throws LensException

Get all databases in the metastore

Parameters:: sessionid - The sessionid in which user is working
Returns:: StringList consisting of all database names.
Throws:: javax.ws.rs.WebApplicationException; LensException

getDatabase

@GET
 @Path(value="databases/current")
public String getDatabase(@QueryParam(value="sessionid")
                                                                 LensSessionHandle sessionid)
                                                          throws LensException

Get the current database

Parameters:: sessionid - The sessionid in which user is working
Returns:: The current db name
Throws:: LensException

setDatabase

@PUT
 @Path(value="databases/current")
 @Consumes(value={"application/xml","application/json"})
public APIResult setDatabase(@QueryParam(value="sessionid")
                                                                                                                             LensSessionHandle sessionid,
                                                                                                                             String dbName)
                                                                                                                      throws LensException

Set the current db

Parameters:: sessionid - The sessionid in which user is working; dbName - The db name
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if set was successful. APIResult with state APIResult.Status.FAILED, if set has failed
Throws:: LensException

dropDatabase

@DELETE
 @Path(value="databases/{dbName}")
public APIResult dropDatabase(@QueryParam(value="sessionid")
                                                                         LensSessionHandle sessionid,
                                                                         @PathParam(value="dbName")
                                                                         String dbName,
                                                                         @QueryParam(value="cascade")
                                                                         boolean cascade)
                                                                  throws LensException

Delete the db specified by name. Deleting underlying tables is optional. If db does not exist, delete is ignored.

Parameters:: sessionid - The sessionid in which user is working; dbName - The db name; cascade - if true, all the tables inside the db will also be dropped.
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if delete was successful. APIResult with state APIResult.Status.FAILED, if delete has failed
Throws:: LensException

createDatabase

@POST
 @Path(value="databases")
public APIResult createDatabase(@QueryParam(value="sessionid")
                                                                LensSessionHandle sessionid,
                                                                @QueryParam(value="ignoreIfExisting") @DefaultValue(value="true")
                                                                boolean ignoreIfExisting,
                                                                String dbName)
                                                         throws LensException

Create a new database

Parameters:: sessionid - The sessionid in which user is working; ignoreIfExisting - If true, create will be ignored if db already exists, otherwise it fails.; dbName - The db name
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if create was successful. APIResult with state APIResult.Status.FAILED, if create has failed
Throws:: LensException

getAllNativeTables

@GET
 @Path(value="nativetables")
public StringList getAllNativeTables(@QueryParam(value="sessionid")
                                                                       LensSessionHandle sessionid,
                                                                       @QueryParam(value="dbOption")
                                                                       String dbOption,
                                                                       @QueryParam(value="dbName")
                                                                       String dbName)
                                                                throws LensException

Get all native tables.

Parameters:: sessionid - The sessionid in which user is working; dbOption - The options available are 'current' and 'all'. If option is current, gives all tables from current db. If option is all, gives all tables from all databases. If dbname is passed, dbOption is ignored. If no dbOption or dbname are passed, then default is to get tables from current db.; dbName - The db name. If not empty, the tables in the db will be returned
Returns:: StringList consisting of all table names.
Throws:: javax.ws.rs.WebApplicationException; LensException

getNativeTable

@GET
 @Path(value="nativetables/{tableName}")
public JAXBElement<XNativeTable> getNativeTable(@QueryParam(value="sessionid")
                                                                                              LensSessionHandle sessionid,
                                                                                              @PathParam(value="tableName")
                                                                                              String tableName)
                                                                                       throws LensException

Get the native table passed in name

Parameters:: sessionid - The sessionid in which user is working; tableName - The native table name
Returns:: JAXB representation of XNativeTable
Throws:: javax.ws.rs.WebApplicationException; LensException

getAllCubes

@GET
 @Path(value="cubes")
public StringList getAllCubes(@QueryParam(value="sessionid")
                                                         LensSessionHandle sessionid,
                                                         @QueryParam(value="type") @DefaultValue(value="all")
                                                         String cubeTypes)
                                                  throws LensException

Get all cubes in the metastores, of the specified type

Parameters:: sessionid - The sessionid in which user is working; cubeTypes - The type of cubes. Accepted values are 'all' or 'base' or 'derived' or 'queryable'
Returns:: StringList consisting of all cubes names
Throws:: LensException

deleteAllCubes
```
@DELETE
 @Path(value="cubes")
public APIResult deleteAllCubes(@QueryParam(value="sessionid")
                                                              LensSessionHandle sessionid)
                                                       throws LensException
```
Delete all cubes

Parameters:

sessionid - The sessionid in which user is working

Returns:

APIResult with state APIResult.Status.SUCCEEDED in case of successful delete. APIResult with state APIResult.Status.FAILED in case of delete failure. APIResult with state APIResult.Status.PARTIAL in case of partial delete.

Throws:

LensException

createNewCube

@POST
 @Path(value="cubes")
public APIResult createNewCube(@QueryParam(value="sessionid")
                                                           LensSessionHandle sessionid,
                                                           XCube cube)
                                                    throws LensException

Create a new cube

Parameters:: sessionid - The sessionid in which user is working; cube - The XCube representation of the cube definition
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if create was successful. APIResult with state APIResult.Status.FAILED, if create has failed
Throws:: LensException

updateCube

@PUT
 @Path(value="/cubes/{cubeName}")
public APIResult updateCube(@QueryParam(value="sessionid")
                                                                   LensSessionHandle sessionid,
                                                                   @PathParam(value="cubeName")
                                                                   String cubeName,
                                                                   XCube cube)
                                                            throws LensException

Update cube definition

Parameters:: sessionid - The sessionid in which user is working; cubeName - The cube name; cube - The XCube representation of the updated cube definition
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if update was successful. APIResult with state APIResult.Status.FAILED, if update has failed
Throws:: LensException

getCube

@GET
 @Path(value="/cubes/{cubeName}")
public JAXBElement<XCube> getCube(@QueryParam(value="sessionid")
                                                                         LensSessionHandle sessionid,
                                                                         @PathParam(value="cubeName")
                                                                         String cubeName)
                                                                  throws LensException

Get the cube specified by name

Parameters:: sessionid - The sessionid in which user is working; cubeName - The cube name
Returns:: JAXB representation of XCube
Throws:: LensException

dropCube

@DELETE
 @Path(value="/cubes/{cubeName}")
public APIResult dropCube(@QueryParam(value="sessionid")
                                                                    LensSessionHandle sessionid,
                                                                    @PathParam(value="cubeName")
                                                                    String cubeName)
                                                             throws LensException

Drop the cube, specified by name

Parameters:: sessionid - The sessionid in which user is working; cubeName - The cube name
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

getAllStorages

@GET
 @Path(value="storages")
public StringList getAllStorages(@QueryParam(value="sessionid")
                                                               LensSessionHandle sessionid)
                                                        throws LensException

Get all storages in the metastore

Parameters:: sessionid - The sessionid in which user is working
Returns:: StringList consisting of all the storage names
Throws:: javax.ws.rs.WebApplicationException - Wraps LensException; LensException

createNewStorage

@POST
 @Path(value="storages")
public APIResult createNewStorage(@QueryParam(value="sessionid")
                                                                 LensSessionHandle sessionid,
                                                                 XStorage storage)
                                                          throws LensException

Create new storage

Parameters:: sessionid - The sessionid in which user is working; storage - The XStorage representation of storage
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if create was successful. APIResult with state APIResult.Status.FAILED, if create has failed
Throws:: LensException

deleteAllStorages

@DELETE
 @Path(value="storages")
public APIResult deleteAllStorages(@QueryParam(value="sessionid")
                                                                    LensSessionHandle sessionid)
                                                             throws LensException

Delete all storages in metastore

Parameters:: sessionid - The sessionid in which user is working
Returns:: APIResult with state APIResult.Status.SUCCEEDED in case of successful delete. APIResult with state APIResult.Status.FAILED in case of delete failure. APIResult with state APIResult.Status.PARTIAL in case of partial delete.
Throws:: LensException

updateStorage

@PUT
 @Path(value="/storages/{storageName}")
public APIResult updateStorage(@QueryParam(value="sessionid")
                                                                            LensSessionHandle sessionid,
                                                                            @PathParam(value="storageName")
                                                                            String storageName,
                                                                            XStorage storage)
                                                                     throws LensException

Update storage definition

Parameters:: sessionid - The sessionid in which user is working; storageName - The storage name; storage - The XStorage representation of the updated storage definition
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if update was successful. APIResult with state APIResult.Status.FAILED, if update has failed
Throws:: LensException

getStorage

@GET
 @Path(value="/storages/{storage}")
public JAXBElement<XStorage> getStorage(@QueryParam(value="sessionid")
                                                                                 LensSessionHandle sessionid,
                                                                                 @PathParam(value="storage")
                                                                                 String storageName)
                                                                          throws LensException

Get the storage specified by name

Parameters:: sessionid - The sessionid in which user is working; storageName - The storage name
Returns:: JAXB representation of XStorage
Throws:: LensException

dropStorage

@DELETE
 @Path(value="/storages/{storage}")
public APIResult dropStorage(@QueryParam(value="sessionid")
                                                                         LensSessionHandle sessionid,
                                                                         @PathParam(value="storage")
                                                                         String storageName)
                                                                  throws LensException

Drop the storage, specified by name

Parameters:: sessionid - The sessionid in which user is working; storageName - The storage name
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

getAllDimensionNames

@GET
 @Path(value="dimensions")
public StringList getAllDimensionNames(@QueryParam(value="sessionid")
                                                                       LensSessionHandle sessionid)
                                                                throws LensException

Get all dimensions in the metastore

Parameters:: sessionid - The sessionid in which user is working
Returns:: StringList consisting of all the dimension names
Throws:: javax.ws.rs.WebApplicationException - wraps lensException; LensException

createDimension

@POST
 @Path(value="dimensions")
public APIResult createDimension(@QueryParam(value="sessionid")
                                                                  LensSessionHandle sessionid,
                                                                  XDimension dimension)
                                                           throws LensException

Create new dimension

Parameters:: sessionid - The sessionid in which user is working; dimension - The XDimension representation of dimension
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if create was successful. APIResult with state APIResult.Status.FAILED, if create has failed
Throws:: LensException

deleteAllDimensions

@DELETE
 @Path(value="dimensions")
public APIResult deleteAllDimensions(@QueryParam(value="sessionid")
                                                                        LensSessionHandle sessionid)
                                                                 throws LensException

Delete all dimensions in metastore

Parameters:: sessionid - The sessionid in which user is working
Returns:: APIResult with state APIResult.Status.SUCCEEDED in case of successful delete. APIResult with state APIResult.Status.FAILED in case of delete failure. APIResult with state APIResult.Status.PARTIAL in case of partial delete.
Throws:: LensException

updateDimension

@PUT
 @Path(value="/dimensions/{dimName}")
public APIResult updateDimension(@QueryParam(value="sessionid")
                                                                            LensSessionHandle sessionid,
                                                                            @PathParam(value="dimName")
                                                                            String dimName,
                                                                            XDimension dimension)
                                                                     throws LensException

Update dimension definition

Parameters:: sessionid - The sessionid in which user is working; dimName - The dimension name; dimension - The XDimension representation of the updated dimension definition
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if update was successful. APIResult with state APIResult.Status.FAILED, if update has failed
Throws:: LensException

getDimension

@GET
 @Path(value="/dimensions/{dimName}")
public JAXBElement<XDimension> getDimension(@QueryParam(value="sessionid")
                                                                                       LensSessionHandle sessionid,
                                                                                       @PathParam(value="dimName")
                                                                                       String dimName)
                                                                                throws LensException

Get the dimension specified by name

Parameters:: sessionid - The sessionid in which user is working; dimName - The dimension name
Returns:: JAXB representation of XDimension
Throws:: LensException

dropDimension

@DELETE
 @Path(value="/dimensions/{dimName}")
public APIResult dropDimension(@QueryParam(value="sessionid")
                                                                             LensSessionHandle sessionid,
                                                                             @PathParam(value="dimName")
                                                                             String dimName)
                                                                      throws LensException

Drop the dimension, specified by name

Parameters:: sessionid - The sessionid in which user is working; dimName - The dimension name
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

getAllDimensionTablesOfDimension

@GET
 @Path(value="/dimensions/{dimName}/dimtables")
public StringList getAllDimensionTablesOfDimension(@QueryParam(value="sessionid")
                                                                                                        LensSessionHandle sessionid,
                                                                                                        @PathParam(value="dimName")
                                                                                                        String dimensionName)
                                                                                                 throws LensException

Get all dimtables that belong to a dimension in the metastore

Parameters:: sessionid - The sessionid in which user is working; dimensionName - name of the dimension
Returns:: List of XDimensionTable objects
Throws:: LensException

getAllFactsOfCube

@GET
 @Path(value="/cubes/{cubeName}/facts")
public StringList getAllFactsOfCube(@QueryParam(value="sessionid")
                                                                                 LensSessionHandle sessionid,
                                                                                 @PathParam(value="cubeName")
                                                                                 String cubeName)
                                                                          throws LensException

Get all facts that belong to a cube in the metastore

Parameters:: sessionid - The sessionid in which user is working; cubeName - name of the base cube or derived cube
Returns:: StringList consisting of all the fact names in the given cube
Throws:: LensException

getAllSegmentationsOfCube

@GET
 @Path(value="/cubes/{cubeName}/segmentations")
public StringList getAllSegmentationsOfCube(@QueryParam(value="sessionid")
                                                                                                 LensSessionHandle sessionid,
                                                                                                 @PathParam(value="cubeName")
                                                                                                 String cubeName)
                                                                                          throws LensException

Get all segmentations that belong to a cube in the metastore

Parameters:: sessionid - The sessionid in which user is working; cubeName - name of the base cube or derived cube
Returns:: List of XSegmentation objects
Throws:: LensException

getAllFacts

@GET
 @Path(value="/facts")
public StringList getAllFacts(@QueryParam(value="sessionid")
                                                          LensSessionHandle sessionid)
                                                   throws LensException

Get all fact tables in the metastore in the current database

Parameters:: sessionid - The sessionid in which user is working
Returns:: StringList consisting of all fact table names
Throws:: LensException

getAllSegmentations

@GET
 @Path(value="/segmentations")
public StringList getAllSegmentations(@QueryParam(value="sessionid")
                                                                          LensSessionHandle sessionid)
                                                                   throws LensException

Get all segmentations in the current database

Parameters:: sessionid - The sessionid in which user is working
Returns:: StringList consisting of all segmentations
Throws:: LensException

deleteAllFacts

@DELETE
 @Path(value="facts")
public APIResult deleteAllFacts(@QueryParam(value="sessionid")
                                                              LensSessionHandle sessionid,
                                                              @DefaultValue(value="false") @QueryParam(value="cascade")
                                                              boolean cascade)
                                                       throws LensException

Delete all fact tables

Parameters:: sessionid - The sessionid in which user is working; cascade - if set to true, all the underlying tables will be dropped, if set to false, only the fact table will be dropped
Returns:: APIResult with state APIResult.Status.SUCCEEDED in case of successful delete. APIResult with state APIResult.Status.FAILED in case of delete failure. APIResult with state APIResult.Status.PARTIAL in case of partial delete.
Throws:: LensException

deleteAllSegmentations

@DELETE
 @Path(value="segmentations")
public APIResult deleteAllSegmentations(@QueryParam(value="sessionid")
                                                                              LensSessionHandle sessionid)
                                                                       throws LensException

Delete all segmentations

Parameters:: sessionid - The sessionid in which user is working
Returns:: APIResult with state APIResult.Status.SUCCEEDED in case of successful delete. APIResult with state APIResult.Status.FAILED in case of delete failure. APIResult with state APIResult.Status.PARTIAL in case of partial delete.
Throws:: LensException

getFactTable

@GET
 @Path(value="/facts/{factName}")
public JAXBElement<XFact> getFactTable(@QueryParam(value="sessionid")
                                                                              LensSessionHandle sessionid,
                                                                              @PathParam(value="factName")
                                                                              String factName)
                                                                       throws LensException

Get the fact table specified by name

Parameters:: sessionid - The sessionid in which user is working; factName - The fact table name
Returns:: JAXB representation of XFact
Throws:: LensException

getSegmentation

@GET
 @Path(value="/segmentations/{segmentationName}")
public JAXBElement<XSegmentation> getSegmentation(@QueryParam(value="sessionid")
                                                                                                         LensSessionHandle sessionid,
                                                                                                         @PathParam(value="segmentationName")
                                                                                                         String segmentationName)
                                                                                                  throws LensException

Get the segmentation specified by name

Parameters:: sessionid - The sessionid in which user is working; segmentationName - The segmentation name
Returns:: JAXB representation of XSegmentation
Throws:: LensException

createFactTable

@POST
 @Path(value="/facts")
public APIResult createFactTable(@QueryParam(value="sessionid")
                                                              LensSessionHandle sessionid,
                                                              XFact fact)
                                                       throws LensException

Create a new fact tabble

Parameters:: sessionid - The sessionid in which user is working; fact - The XFact representation of the fact table definition
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if create was successful. APIResult with state APIResult.Status.FAILED, if create has failed
Throws:: LensException

createSegmentation

@POST
 @Path(value="/segmentations")
public APIResult createSegmentation(@QueryParam(value="sessionid")
                                                                         LensSessionHandle sessionid,
                                                                         XSegmentation seg)
                                                                  throws LensException

Create a new segmentation

Parameters:: sessionid - The sessionid in which user is working; seg - The XSegmentation representation of the segmentation
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if create was successful. APIResult with state APIResult.Status.FAILED, if create has failed
Throws:: LensException

updateFactTable

@PUT
 @Path(value="/facts/{factName}")
public APIResult updateFactTable(@QueryParam(value="sessionid")
                                                                        LensSessionHandle sessionid,
                                                                        @PathParam(value="factName")
                                                                        String factName,
                                                                        XFact fact)
                                                                 throws LensException

Update fact table definition

Parameters:: sessionid - The sessionid in which user is working; factName - name of the fact table; fact - The XFact representation of the updated fact table definition
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if update was successful. APIResult with state APIResult.Status.FAILED, if update has failed
Throws:: LensException

updateSegmentation

@PUT
 @Path(value="/segmentations/{segmentationName}")
public APIResult updateSegmentation(@QueryParam(value="sessionid")
                                                                                           LensSessionHandle sessionid,
                                                                                           @PathParam(value="segmentationName")
                                                                                           String segmentationName,
                                                                                           XSegmentation seg)
                                                                                    throws LensException

Update segmentation

Parameters:: sessionid - The sessionid in which user is working; segmentationName - name of segmentation; seg - The XSegmentation representation of the updated fact table definition
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if update was successful. APIResult with state APIResult.Status.FAILED, if update has failed
Throws:: LensException

dropFactTable

@DELETE
 @Path(value="/facts/{factName}")
public APIResult dropFactTable(@QueryParam(value="sessionid")
                                                                         LensSessionHandle sessionid,
                                                                         @PathParam(value="factName")
                                                                         String factName,
                                                                         @DefaultValue(value="false") @QueryParam(value="cascade")
                                                                         boolean cascade)
                                                                  throws LensException

Drop the fact table, specified by name

Parameters:: sessionid - The sessionid in which user is working; factName - The fact table name; cascade - If true, all the storage tables of the fact will also be dropped
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

dropSegmentation

@DELETE
 @Path(value="/segmentations/{segmentationName}")
public APIResult dropSegmentation(@QueryParam(value="sessionid")
                                                                                            LensSessionHandle sessionid,
                                                                                            @PathParam(value="segmentationName")
                                                                                            String segmentationName)
                                                                                     throws LensException

Drop the segmentation, specified by name

Parameters:: sessionid - The sessionid in which user is working; segmentationName - The segmentation name
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

getStoragesOfFact

@GET
 @Path(value="/facts/{factName}/storages")
public StringList getStoragesOfFact(@QueryParam(value="sessionid")
                                                                                    LensSessionHandle sessionid,
                                                                                    @PathParam(value="factName")
                                                                                    String factName)
                                                                             throws LensException

Get all storages of the fact table in the metastore

Parameters:: sessionid - The sessionid in which user is working; factName - The fact table name
Returns:: StringList consisting of all the storage names
Throws:: LensException

dropAllStoragesOfFact

@DELETE
 @Path(value="/facts/{factName}/storages")
public APIResult dropAllStoragesOfFact(@QueryParam(value="sessionid")
                                                                                          LensSessionHandle sessionid,
                                                                                          @PathParam(value="factName")
                                                                                          String factName)
                                                                                   throws LensException

Drop all the storage tables of a fact table

Parameters:: sessionid - The sessionid in which user is working; factName - The fact table name
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

addStorageToFact

@POST
 @Path(value="/facts/{factName}/storages")
public APIResult addStorageToFact(@QueryParam(value="sessionid")
                                                                                   LensSessionHandle sessionid,
                                                                                   @PathParam(value="factName")
                                                                                   String factName,
                                                                                   XStorageTableElement storageTable)
                                                                            throws LensException

Add storage to fact table

Parameters:: sessionid - The sessionid in which user is working; factName - The fact table name; storageTable - The storage table description
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if add was successful. APIResult with state APIResult.Status.FAILED, if add has failed
Throws:: LensException

dropStorageFromFact

@DELETE
 @Path(value="/facts/{factName}/storages/{storage}")
public APIResult dropStorageFromFact(@QueryParam(value="sessionid")
                                                                                                  LensSessionHandle sessionid,
                                                                                                  @PathParam(value="factName")
                                                                                                  String factName,
                                                                                                  @PathParam(value="storage")
                                                                                                  String storage)
                                                                                           throws LensException

Drop the storage of a fact, specified by name

Parameters:: sessionid - The sessionid in which user is working; factName - The fact table name; storage - The storage name
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

getStorageOfFact

@GET
 @Path(value="/facts/{factName}/storages/{storage}")
public JAXBElement<XStorageTableElement> getStorageOfFact(@QueryParam(value="sessionid")
                                                                                                                    LensSessionHandle sessionid,
                                                                                                                    @PathParam(value="factName")
                                                                                                                    String factName,
                                                                                                                    @PathParam(value="storage")
                                                                                                                    String storage)
                                                                                                             throws LensException

Get the fact storage table

Parameters:: sessionid - The sessionid in which user is working; factName - The fact table name; storage - The storage name
Returns:: JAXB representation of XStorageTableElement
Throws:: LensException

getAllPartitionsOfFactStorageByFilter

@GET
 @Path(value="/facts/{factName}/storages/{storage}/partitions")
public JAXBElement<XPartitionList> getAllPartitionsOfFactStorageByFilter(@QueryParam(value="sessionid")
                                                                                                                                              LensSessionHandle sessionid,
                                                                                                                                              @PathParam(value="factName")
                                                                                                                                              String factName,
                                                                                                                                              @PathParam(value="storage")
                                                                                                                                              String storage,
                                                                                                                                              @QueryParam(value="filter")
                                                                                                                                              String filter)
                                                                                                                                       throws LensException

Get all partitions of the fact table in the specified storage; can be filtered as well.

Parameters:: sessionid - The sessionid in which user is working; factName - The fact table name; storage - The storage name; filter - The filter for partitions, string representation of the filter for ex: x < "xxx" and y > "yyy"
Returns:: JAXB representation of XPartitionList containing XPartition objects
Throws:: LensException

dropPartitionsOfFactStorageByFilter

@DELETE
 @Path(value="/facts/{factName}/storages/{storage}/partitions")
public APIResult dropPartitionsOfFactStorageByFilter(@QueryParam(value="sessionid")
                                                                                                                             LensSessionHandle sessionid,
                                                                                                                             @PathParam(value="factName")
                                                                                                                             String factName,
                                                                                                                             @PathParam(value="storage")
                                                                                                                             String storage,
                                                                                                                             @QueryParam(value="filter")
                                                                                                                             String filter)
                                                                                                                      throws LensException

Drop the partitions in the storage of a fact; can specified filter as well

Parameters:: sessionid - The sessionid in which user is working; factName - The fact table name; storage - The storage name; filter - The filter for partitions, string representation of the filter for ex: x < "xxx" and y > "yyy"
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

addPartitionToFactStorage

@POST
 @Path(value="/facts/{factName}/storages/{storage}/partition")
public APIResult addPartitionToFactStorage(@QueryParam(value="sessionid")
                                                                                                                LensSessionHandle sessionid,
                                                                                                                @PathParam(value="factName")
                                                                                                                String factName,
                                                                                                                @PathParam(value="storage")
                                                                                                                String storage,
                                                                                                                XPartition partition)
                                                                                                         throws LensException

Add a new partition for a storage of fact

Parameters:: sessionid - The sessionid in which user is working; factName - fact table name; storage - storage name; partition - XPartition representation of partition
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if add was successful. APIResult with state APIResult.Status.FAILED, if add has failed
Throws:: LensException

updatePartitionOfFactStorage

@PUT
 @Path(value="/facts/{factName}/storages/{storage}/partition")
public APIResult updatePartitionOfFactStorage(@QueryParam(value="sessionid")
                                                                                                                  LensSessionHandle sessionid,
                                                                                                                  @PathParam(value="factName")
                                                                                                                  String factName,
                                                                                                                  @PathParam(value="storage")
                                                                                                                  String storage,
                                                                                                                  XPartition partition)
                                                                                                           throws LensException

updates an existing partition for a storage of fact

Parameters:: sessionid - The sessionid in which user is working; factName - fact table name; storage - storage name; partition - XPartition representation of partition.
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if update was successful. APIResult with state APIResult.Status.FAILED, if update has failed
Throws:: LensException

addPartitionsToFactStorage

@POST
 @Path(value="/facts/{factName}/storages/{storage}/partitions")
public APIResult addPartitionsToFactStorage(@QueryParam(value="sessionid")
                                                                                                                  LensSessionHandle sessionid,
                                                                                                                  @PathParam(value="factName")
                                                                                                                  String factName,
                                                                                                                  @PathParam(value="storage")
                                                                                                                  String storage,
                                                                                                                  XPartitionList partitions)
                                                                                                           throws LensException

Batch Add partitions for a storage of fact

Parameters:: sessionid - The sessionid in which user is working; factName - fact table name; storage - storage name; partitions - XPartitionList representation of partitions
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if add was successful. APIResult with state APIResult.Status.FAILED, if add has failed
Throws:: LensException

updatePartitionsOfFactStorage

@PUT
 @Path(value="/facts/{factName}/storages/{storage}/partitions")
public APIResult updatePartitionsOfFactStorage(@QueryParam(value="sessionid")
                                                                                                                    LensSessionHandle sessionid,
                                                                                                                    @PathParam(value="factName")
                                                                                                                    String factName,
                                                                                                                    @PathParam(value="storage")
                                                                                                                    String storage,
                                                                                                                    XPartitionList partitions)
                                                                                                             throws LensException

Batch Update partitions for a storage of fact

Parameters:: sessionid - The sessionid in which user is working; factName - fact table name; storage - storage name; partitions - XPartitionList representation of partitions
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if update was successful. APIResult with state APIResult.Status.FAILED, if update has failed
Throws:: LensException

dropPartitionOfFactStorageByValues

@DELETE
 @Path(value="/facts/{factName}/storages/{storage}/partition")
public APIResult dropPartitionOfFactStorageByValues(@QueryParam(value="sessionid")
                                                                                                                           LensSessionHandle sessionid,
                                                                                                                           @PathParam(value="factName")
                                                                                                                           String factName,
                                                                                                                           @PathParam(value="storage")
                                                                                                                           String storage,
                                                                                                                           @QueryParam(value="values")
                                                                                                                           String values)
                                                                                                                    throws LensException

Drop the partitions in the storage of a fact table, specified by exact values

Parameters:: sessionid - The sessionid in which user is working; factName - The fact table name; storage - The storage name; values - Comma separated values
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

getAllDims

@GET
 @Path(value="/dimtables")
public StringList getAllDims(@QueryParam(value="sessionid")
                                                             LensSessionHandle sessionid)
                                                      throws LensException

Get all dimension tables in the metastore

Parameters:: sessionid - The sessionid in which user is working
Returns:: StringList consisting of all dimension table names
Throws:: LensException

createDimensionTable

@POST
 @Path(value="/dimtables")
public APIResult createDimensionTable(@QueryParam(value="sessionid")
                                                                       LensSessionHandle sessionid,
                                                                       XDimensionTable dimensionTable)
                                                                throws LensException

Create a new dimension table

Parameters:: sessionid - The sessionid in which user is working; dimensionTable - The XDimensionTable representation of the dimension table definition
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if create was successful. APIResult with state APIResult.Status.FAILED, if create has failed
Throws:: LensException

updateCubeDimension

@PUT
 @Path(value="/dimtables/{dimTableName}")
public APIResult updateCubeDimension(@QueryParam(value="sessionid")
                                                                                    LensSessionHandle sessionid,
                                                                                    @PathParam(value="dimTableName")
                                                                                    String dimTableName,
                                                                                    XDimensionTable dimensionTable)
                                                                             throws LensException

Update dimension table definition

Parameters:: sessionid - The sessionid in which user is working; dimensionTable - The XDimensionTable representation of the updated dim table definition
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if update was successful. APIResult with state APIResult.Status.FAILED, if update has failed
Throws:: LensException

dropDimensionTable

@DELETE
 @Path(value="/dimtables/{dimTableName}")
public APIResult dropDimensionTable(@QueryParam(value="sessionid")
                                                                                      LensSessionHandle sessionid,
                                                                                      @PathParam(value="dimTableName")
                                                                                      String dimension,
                                                                                      @QueryParam(value="cascade")
                                                                                      boolean cascade)
                                                                               throws LensException

Drop the dimension table, specified by name

Parameters:: sessionid - The sessionid in which user is working; dimension - The dimension table name; cascade - if true, all the storage tables of dimension table will also be dropped
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

getDimensionTable

@GET
 @Path(value="/dimtables/{dimTableName}")
public JAXBElement<XDimensionTable> getDimensionTable(@QueryParam(value="sessionid")
                                                                                                     LensSessionHandle sessionid,
                                                                                                     @PathParam(value="dimTableName")
                                                                                                     String dimTableName)
                                                                                              throws LensException

Get the dimension table specified by name

Parameters:: sessionid - The sessionid in which user is working; dimTableName - The cube name
Returns:: JAXB representation of XDimensionTable
Throws:: LensException

getDimensionStorages

@GET
 @Path(value="/dimtables/{dimTableName}/storages")
public StringList getDimensionStorages(@QueryParam(value="sessionid")
                                                                                               LensSessionHandle sessionid,
                                                                                               @PathParam(value="dimTableName")
                                                                                               String dimension)
                                                                                        throws LensException

Get all storages of the dimension table in the metastore

Parameters:: sessionid - The sessionid in which user is working; dimension - The dimension table name
Returns:: StringList consisting of all the storage names
Throws:: LensException

createDimensionStorage

@POST
 @Path(value="/dimtables/{dimTableName}/storages")
public APIResult createDimensionStorage(@QueryParam(value="sessionid")
                                                                                                 LensSessionHandle sessionid,
                                                                                                 @PathParam(value="dimTableName")
                                                                                                 String dimTableName,
                                                                                                 XStorageTableElement storageTbl)
                                                                                          throws LensException

Add storage to dimension table

Parameters:: sessionid - The sessionid in which user is working; dimTableName - The dimension table name; storageTbl - The Storage table description
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if add was successful. APIResult with state APIResult.Status.FAILED, if add has failed
Throws:: LensException

getStorageOfDim

@GET
 @Path(value="/dimtables/{dimTableName}/storages/{storage}")
public JAXBElement<XStorageTableElement> getStorageOfDim(@QueryParam(value="sessionid")
                                                                                                                           LensSessionHandle sessionid,
                                                                                                                           @PathParam(value="dimTableName")
                                                                                                                           String dimTableName,
                                                                                                                           @PathParam(value="storage")
                                                                                                                           String storage)
                                                                                                                    throws LensException

Get the dim storage table

Parameters:: sessionid - The sessionid in which user is working; dimTableName - The fact table name; storage - The storage name
Returns:: JAXB representation of XStorageTableElement
Throws:: LensException

dropAllStoragesOfDim

@DELETE
 @Path(value="/dimtables/{dimTableName}/storages")
public APIResult dropAllStoragesOfDim(@QueryParam(value="sessionid")
                                                                                                 LensSessionHandle sessionid,
                                                                                                 @PathParam(value="dimTableName")
                                                                                                 String dimTableName)
                                                                                          throws LensException

Drop all the storage tables of a dimension table

Parameters:: sessionid - The sessionid in which user is working; dimTableName - The dimension table name
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

dropStorageOfDim

@DELETE
 @Path(value="/dimtables/{dimTableName}/storages/{storage}")
public APIResult dropStorageOfDim(@QueryParam(value="sessionid")
                                                                                                       LensSessionHandle sessionid,
                                                                                                       @PathParam(value="dimTableName")
                                                                                                       String dimTableName,
                                                                                                       @PathParam(value="storage")
                                                                                                       String storage)
                                                                                                throws LensException

Drop the storage of a dimension table, specified by name

Parameters:: sessionid - The sessionid in which user is working; dimTableName - The dimension table name; storage - The storage name
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

getAllPartitionsOfDimStorage

@GET
 @Path(value="/dimtables/{dimTableName}/storages/{storage}/partitions")
public JAXBElement<XPartitionList> getAllPartitionsOfDimStorage(@QueryParam(value="sessionid")
                                                                                                                                             LensSessionHandle sessionid,
                                                                                                                                             @PathParam(value="dimTableName")
                                                                                                                                             String dimension,
                                                                                                                                             @PathParam(value="storage")
                                                                                                                                             String storage,
                                                                                                                                             @QueryParam(value="filter")
                                                                                                                                             String filter)
                                                                                                                                      throws LensException

Get all partition of the dimension table in the specified storage; can be filtered

Parameters:: sessionid - The sessionid in which user is working; dimension - The dimension table name; storage - The storage name; filter - The filter for partitions, string representation of the filter for ex: x < "xxx" and y > "yyy"
Returns:: JAXB representation of XPartitionList containing XPartition objects
Throws:: LensException

dropPartitionsOfDimStorageByFilter

@DELETE
 @Path(value="/dimtables/{dimTableName}/storages/{storage}/partitions")
public APIResult dropPartitionsOfDimStorageByFilter(@QueryParam(value="sessionid")
                                                                                                                                    LensSessionHandle sessionid,
                                                                                                                                    @PathParam(value="dimTableName")
                                                                                                                                    String dimTableName,
                                                                                                                                    @PathParam(value="storage")
                                                                                                                                    String storage,
                                                                                                                                    @QueryParam(value="filter")
                                                                                                                                    String filter)
                                                                                                                             throws LensException

Drop the partitions in the storage of a dimension table; can specified filter as well

Parameters:: sessionid - The sessionid in which user is working; dimTableName - The dimension table name; storage - The storage name; filter - The filter for partitions, string representation of the filter for ex: x < 'xxx' and y > 'yyy'
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

dropPartitionsOfDimStorageByValue

@DELETE
 @Path(value="/dimtables/{dimTableName}/storages/{storage}/partition")
public APIResult dropPartitionsOfDimStorageByValue(@QueryParam(value="sessionid")
                                                                                                                                  LensSessionHandle sessionid,
                                                                                                                                  @PathParam(value="dimTableName")
                                                                                                                                  String dimTableName,
                                                                                                                                  @PathParam(value="storage")
                                                                                                                                  String storage,
                                                                                                                                  @QueryParam(value="values")
                                                                                                                                  String values)
                                                                                                                           throws LensException

Drop the partitions in the storage of a dimension table, specified by exact values

Parameters:: sessionid - The sessionid in which user is working; dimTableName - The dimension table name; storage - The storage name; values - Comma separated values
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if drop was successful. APIResult with state APIResult.Status.FAILED, if drop has failed
Throws:: LensException

addPartitionToDimStorage

@POST
 @Path(value="/dimtables/{dimTableName}/storages/{storage}/partition")
public APIResult addPartitionToDimStorage(@QueryParam(value="sessionid")
                                                                                                                       LensSessionHandle sessionid,
                                                                                                                       @PathParam(value="dimTableName")
                                                                                                                       String dimTableName,
                                                                                                                       @PathParam(value="storage")
                                                                                                                       String storage,
                                                                                                                       XPartition partition)
                                                                                                                throws LensException

Add a new partition for a storage of dimension

Parameters:: sessionid - The sessionid in which user is working; dimTableName - dimension table name; storage - storage name; partition - XPartition representation of partition
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if add was successful. APIResult with state APIResult.Status.FAILED, if add has failed
Throws:: LensException

updatePartitionOfDimStorage

@PUT
 @Path(value="/dimtables/{dimTableName}/storages/{storage}/partition")
public APIResult updatePartitionOfDimStorage(@QueryParam(value="sessionid")
                                                                                                                         LensSessionHandle sessionid,
                                                                                                                         @PathParam(value="dimTableName")
                                                                                                                         String dimTableName,
                                                                                                                         @PathParam(value="storage")
                                                                                                                         String storage,
                                                                                                                         XPartition partition)
                                                                                                                  throws LensException

Updates an existing partition for a storage of dimension

Parameters:: sessionid - The sessionid in which user is working; dimTableName - dimension table name; storage - storage name; partition - XPartition representation of partition
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if update was successful. APIResult with state APIResult.Status.FAILED, if update has failed
Throws:: LensException

addPartitionsToDimStorage

@POST
 @Path(value="/dimtables/{dimTableName}/storages/{storage}/partitions")
public APIResult addPartitionsToDimStorage(@QueryParam(value="sessionid")
                                                                                                                         LensSessionHandle sessionid,
                                                                                                                         @PathParam(value="dimTableName")
                                                                                                                         String dimTableName,
                                                                                                                         @PathParam(value="storage")
                                                                                                                         String storage,
                                                                                                                         XPartitionList partitions)
                                                                                                                  throws LensException

Add new partitions for a storage of dimension

Parameters:: sessionid - The sessionid in which user is working; dimTableName - dimension table name; storage - storage name; partitions - XPartitionList representation of list of partitions
Returns:: APIResult with state APIResult.Status.SUCCEEDED, if add was successful. APIResult with state APIResult.Status.FAILED, if add has failed
Throws:: LensException

updatePartitionsOfDimStorage

@PUT
 @Path(value="/dimtables/{dimTableName}/storages/{storage}/partitions")
public APIResult updatePartitionsOfDimStorage(@QueryParam(value="sessionid")
                                                                                                                           LensSessionHandle sessionid,
                                                                                                                           @PathParam(value="dimTableName")
                                                                                                                           String dimTableName,
                                                                                                                           @PathParam(value="storage")
                                                                                                                           String storage,
                                                                                                                           XPartitionList partitions)
                                                                                                                    throws LensException