Gets a list of databases.

@param nextPageLink The NextLink from the previous successful call to List operation.
@throws IllegalArgumentException thrown if parameters fail the validation
@return the observable to the PagedList&lt;DatabaseInner&gt; object
17371
public Observable<Page<DatabaseInner>> listByServerNextAsync(final String nextPageLink) {
        return listByServerNextWithServiceResponseAsync(nextPageLink)
            .map(new Func1<ServiceResponse<Page<DatabaseInner>>, Page<DatabaseInner>>() {
                @Override
                public Page<DatabaseInner> call(ServiceResponse<Page<DatabaseInner>> response) {
                    return response.body();
                }
            });
    }
267229
public Observable<Page<DomainInner>> listAsync() {
        return listWithServiceResponseAsync().map(new Func1<ServiceResponse<List<DomainInner>>, Page<DomainInner>>() {
            @Override
            public Page<DomainInner> call(ServiceResponse<List<DomainInner>> response) {
                PageImpl<DomainInner> page = new PageImpl<>();
                page.setItems(response.body());
                return page;
            }
        });
    }
33205
public Observable<Page<StorageAccountInner>> listAsync() {
        return listWithServiceResponseAsync().map(new Func1<ServiceResponse<List<StorageAccountInner>>, Page<StorageAccountInner>>() {
            @Override
            public Page<StorageAccountInner> call(ServiceResponse<List<StorageAccountInner>> response) {
                PageImpl<StorageAccountInner> page = new PageImpl<>();
                page.setItems(response.body());
                return page;
            }
        });
    }
363947
public Observable<Page<ManagementLockObjectInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<ManagementLockObjectInner>>, Page<ManagementLockObjectInner>>() {
                @Override
                public Page<ManagementLockObjectInner> call(ServiceResponse<Page<ManagementLockObjectInner>> response) {
                    return response.body();
                }
            });
    }
1037
public Observable<Page<DomainInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<DomainInner>>, Page<DomainInner>>() {
                @Override
                public Page<DomainInner> call(ServiceResponse<Page<DomainInner>> response) {
                    return response.body();
                }
            });
    }
43729
public Observable<Page<FeatureResultInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<FeatureResultInner>>, Page<FeatureResultInner>>() {
                @Override
                public Page<FeatureResultInner> call(ServiceResponse<Page<FeatureResultInner>> response) {
                    return response.body();
                }
            });
    }
178495
@SuppressWarnings("unchecked")
    public List<Map>  getPage(int pageNumber) {

        if (pageNumber < 1) {
            throw new IllegalArgumentException("minimum page index == 1");
        }

        String select = subQuery == null ?
                dialect.formSelect(tableName, columns, null, orderBys, pageSize, (pageNumber - 1) * pageSize) :
                dialect.formSelect(tableName, columns, subQuery, orderBys, pageSize, (pageNumber - 1) * pageSize);

        currentPage = pageNumber;
        return new DB(dbName).findAll(select, params);
    }
158860
public Observable<OperationListResultInner> listAsync() {
        return listWithServiceResponseAsync().map(new Func1<ServiceResponse<OperationListResultInner>, OperationListResultInner>() {
            @Override
            public OperationListResultInner call(ServiceResponse<OperationListResultInner> response) {
                return response.body();
            }
        });
    }
361551
public Observable<Page<AppInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<AppInner>>, Page<AppInner>>() {
                @Override
                public Page<AppInner> call(ServiceResponse<Page<AppInner>> response) {
                    return response.body();
                }
            });
    }
1182636
public Observable<Page<OperationEntityInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<OperationEntityInner>>, Page<OperationEntityInner>>() {
                @Override
                public Page<OperationEntityInner> call(ServiceResponse<Page<OperationEntityInner>> response) {
                    return response.body();
                }
            });
    }
617538
public Observable<Page<LabAccountInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<LabAccountInner>>, Page<LabAccountInner>>() {
                @Override
                public Page<LabAccountInner> call(ServiceResponse<Page<LabAccountInner>> response) {
                    return response.body();
                }
            });
    }
569315
private List<T> computePagedList(List<T> result, HeaderAndBody httpResponse, JSONObject where, Pipe<T> requestingPipe) {
        ReadFilter previousRead = null;
        ReadFilter nextRead = null;

        if (PageConfig.MetadataLocations.WEB_LINKING.equals(pageConfig.getMetadataLocation())) {
            String webLinksRaw = "";
            final String relHeader = "rel";
            final String nextIdentifier = pageConfig.getNextIdentifier();
            final String prevIdentifier = pageConfig.getPreviousIdentifier();
            try {
                webLinksRaw = getWebLinkHeader(httpResponse);
                if (webLinksRaw == null) { // no paging, return result
                    return result;
                }
                List<WebLink> webLinksParsed = WebLinkParser.parse(webLinksRaw);
                for (WebLink link : webLinksParsed) {
                    if (nextIdentifier.equals(link.getParameters().get(relHeader))) {
                        nextRead = new ReadFilter();
                        nextRead.setLinkUri(new URI(link.getUri()));
                    } else if (prevIdentifier.equals(link.getParameters().get(relHeader))) {
                        previousRead = new ReadFilter();
                        previousRead.setLinkUri(new URI(link.getUri()));
                    }

                }
            } catch (URISyntaxException ex) {
                Log.e(TAG, webLinksRaw + " did not contain a valid context URI", ex);
                throw new RuntimeException(ex);
            } catch (ParseException ex) {
                Log.e(TAG, webLinksRaw + " could not be parsed as a web link header", ex);
                throw new RuntimeException(ex);
            }
        } else if (pageConfig.getMetadataLocation().equals(PageConfig.MetadataLocations.HEADERS)) {
            nextRead = pageConfig.getPageParameterExtractor().getNextFilter(httpResponse, RestAdapter.this.pageConfig);
            previousRead = pageConfig.getPageParameterExtractor().getPreviousFilter(httpResponse, RestAdapter.this.pageConfig);
        } else if (pageConfig.getMetadataLocation().equals(PageConfig.MetadataLocations.BODY)) {
            nextRead = pageConfig.getPageParameterExtractor().getNextFilter(httpResponse, RestAdapter.this.pageConfig);
            previousRead = pageConfig.getPageParameterExtractor().getPreviousFilter(httpResponse, RestAdapter.this.pageConfig);
        } else {
            throw new IllegalStateException("Not supported");
        }
        if (nextRead != null) {
            nextRead.setWhere(where);
        }

        if (previousRead != null) {
            previousRead.setWhere(where);
        }

        return new WrappingPagedList<T>(requestingPipe, result, nextRead, previousRead);
    }
365627
private Map getInfoList4PageServiceInnerEx(Map requestParamMap0,String tableName,Map pageMap,String cusWhere,String cusSelect,String modelName,List cusPlaceList) throws Exception{
		//add 201807 ning
		//Map requestParamMap=changeCase4Param(requestParamMap0);
		//add 201902 ning
		Map requestParamMap=new CaseInsensitiveKeyMap();
		if(requestParamMap0!=null){
			requestParamMap.putAll(requestParamMap0);
		}
		String page=(String) pageMap.get("page");
		String rows=(String) pageMap.get("rows");
		String sort=(String) pageMap.get("sort");
		String order=(String) pageMap.get("order");
		String cusSort=(String) pageMap.get("cusSort");
		
		String tempDbType=calcuDbType();
		
		Integer pageNum=Integer.valueOf(page);
		Integer rowsNum=Integer.valueOf(rows);
		
		if(modelName==null || "".equals(modelName)){
			modelName=tableName;
		}
		
		String tempKeyId=calcuIdKey();
		String id=(String) requestParamMap.get(tempKeyId);
		String where="";

		if(cusWhere !=null && !"".equals(cusWhere)){
			where="where "+cusWhere;
		}
		
		String whereCols="";	
		
		Map whereColsMap=requestParamMap;
		if(whereColsMap!=null && !whereColsMap.isEmpty()){
			StringBuilder sb=new StringBuilder("");
			Set<String> keySet=whereColsMap.keySet();
			int i=0;
			for(String key:keySet){
				if(!key.contains(".")){
					continue;
				}
				if(key.contains("dbcol_")){
					continue;
				}				
				String colName=key;
				String realColName=colName.replace(".", CheckModelTypeUtil.DUMMY_SPLIT);
				String colsStr=colName+" as "+realColName;
				if(i==0){
					sb.append(colsStr);	
				}else{
					sb.append(",").append(colsStr);
				}
				i++;
			}
			whereCols=sb.toString();
		}
		
		Map modelEntryMap=getModelEntryMap(requestParamMap,tableName,modelName,dbName,whereCols);
		List placeList=new ArrayList();
		String whereInStr=createWhereInStr(requestParamMap,modelEntryMap,placeList);
		if(whereInStr!=null && !"".equals(whereInStr)){
			if(!where.equals("")){
				where=where+" and "+whereInStr;
			}else{
				where="where "+whereInStr;
			}
		}
		List realPlaceList=new ArrayList();
		//realPlaceList.addAll(placeList);
		if(cusPlaceList==null){
			cusPlaceList=new ArrayList();
		}
		realPlaceList.addAll(cusPlaceList);
		
		//add 20170927
		realPlaceList.addAll(placeList);
		String selectCount="select count(1) from "+tableName+" "+where;
		Integer total=getInnerDao().queryObjJoinCountByCondition(selectCount,realPlaceList.toArray());
		String select="";
		if(cusSelect!=null && !"".equals(cusSelect)){
			select="select "+cusSelect+" from "+tableName+" "+where; 
		}else{
			select="select * from "+tableName+" "+where;
		}

		String orderSql="";
		if(cusSort!=null && !"".equals(cusSort)){
			orderSql="order by "+cusSort;
		}else if(sort!=null && !sort.equals("")){
			orderSql="order by "+sort+" "+order;
		}

		String sql=select+" "+orderSql;
		int startNum=getInnerDao().calcuStartIndex(pageNum-1, rowsNum);
		int endNum=startNum+rowsNum;

		List infoList=getInnerDao().queryObjJoinDataByPageCondition(sql, startNum, endNum,realPlaceList.toArray());
		if(infoList==null){
			infoList=new ArrayList();
		}
		CheckModelTypeUtil.addMetaCols(infoList);

		CheckModelTypeUtil.changeNoStrCols(infoList);
		Map retMap=new HashMap();
		retMap.put("rows", infoList);
		retMap.put("total", total);
		return retMap;
	}
368006
def _next_page(self):
        
        if not self._more_results:
            return None

        query_pb = self._build_protobuf()
        transaction = self.client.current_transaction
        if transaction is None:
            transaction_id = None
        else:
            transaction_id = transaction.id
        read_options = helpers.get_read_options(self._eventual, transaction_id)

        partition_id = entity_pb2.PartitionId(
            project_id=self._query.project, namespace_id=self._query.namespace
        )
        response_pb = self.client._datastore_api.run_query(
            self._query.project, partition_id, read_options, query=query_pb
        )
        entity_pbs = self._process_query_results(response_pb)
        return page_iterator.Page(self, entity_pbs, self.item_to_value)
834931
public Observable<Page<ClusterInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<ClusterInner>>, Page<ClusterInner>>() {
                @Override
                public Page<ClusterInner> call(ServiceResponse<Page<ClusterInner>> response) {
                    return response.body();
                }
            });
    }
585459
public Observable<Page<InterfaceEndpointInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<InterfaceEndpointInner>>, Page<InterfaceEndpointInner>>() {
                @Override
                public Page<InterfaceEndpointInner> call(ServiceResponse<Page<InterfaceEndpointInner>> response) {
                    return response.body();
                }
            });
    }
390498
public static <E> ServiceFuture<List<E>> fromPageResponse(Observable<ServiceResponse<Page<E>>> first, final Func1<String, Observable<ServiceResponse<Page<E>>>> next, final ListOperationCallback<E> callback) {
        final AzureServiceFuture<List<E>> serviceCall = new AzureServiceFuture<>();
        final PagingSubscriber<E> subscriber = new PagingSubscriber<>(serviceCall, next, callback);
        serviceCall.setSubscription(first
            .single()
            .subscribe(subscriber));
        return serviceCall;
    }