A platform for high-performance distributed tool and library development written in C++. It can be deployed in two different cluster modes: standalone or distributed. API for v0.5.0, released on June 13, 2018.
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Classes | Typedefs | Enumerations | Functions | Variables
pdb Namespace Reference

Classes

class  Ack
 
class  AggregationJobStage
 
class  AggregationMap
 
class  Array
 
class  Avg
 
class  AvgResult
 
class  BackendExecuteSelection
 
class  BackendTestSetCopy
 
class  BackendTestSetScan
 
class  BaseQuery
 
class  BroadcastJoinBuildHTJobStage
 
class  BuiltinPartialResult
 
class  CatAddNodeToDatabaseRequest
 
class  CatAddNodeToSetRequest
 
class  CatalogCloseSQLiteDBHandler
 
class  CatalogDatabaseMetadata
 
class  CatalogNodeMetadata
 
class  CatalogPermissionsMetadata
 
class  CatalogPrintMetadata
 
class  CatalogSetMetadata
 
class  CatalogUserTypeMetadata
 
class  CatCreateDatabaseRequest
 
class  CatCreateSetRequest
 
class  CatDeleteDatabaseRequest
 
class  CatDeleteSetRequest
 
class  CatRegisterType
 
class  CatRemoveNodeFromDatabaseRequest
 
class  CatRemoveNodeFromSetRequest
 
class  CatSetObjectTypeRequest
 
class  CatSharedLibraryByNameRequest
 
class  CatSharedLibraryRequest
 
class  CatSharedLibraryResult
 
class  CatTypeNameSearch
 
class  CatTypeNameSearchResult
 
class  CatTypeSearchResult
 
class  CloseConnection
 
class  ComputePlan
 
class  DeleteSet
 
class  DepartmentEmployeeAges
 
class  DepartmentEmployees
 
class  DepartmentTotal
 
class  DispatcherAddData
 
class  DispatcherRegisterPartitionPolicy
 
class  DistributedStorageAddDatabase
 
class  DistributedStorageAddSet
 
class  DistributedStorageAddTempSet
 
class  DistributedStorageCleanup
 
class  DistributedStorageClearSet
 
class  DistributedStorageExportSet
 
class  DistributedStorageRemoveDatabase
 
class  DistributedStorageRemoveHashSet
 
class  DistributedStorageRemoveSet
 
class  DistributedStorageRemoveTempSet
 
class  DoneWithResult
 
class  DoubleSumResult
 
class  DoubleVector
 
class  DoubleVectorResult
 
class  Employee
 
class  ExecuteComputation
 
class  ExecuteQuery
 
class  GenericBlock
 
class  GetListOfNodes
 
class  HashPartitionedJoinBuildHTJobStage
 
class  Holder
 
class  JoinMap
 
class  JoinPairArray
 
struct  JoinMapRecordClass
 
class  JoinRecordList
 
class  JoinMapIterator
 
class  KeepGoing
 
class  KMeansDoubleVector
 
class  ListOfNodes
 
class  MyEmployee
 
class  NodeDispatcherData
 
class  NodeInfo
 
class  Nothing
 
class  OptimizedDepartmentEmployees
 
class  OptimizedEmployee
 
class  OptimizedSupervisor
 
struct  MapRecordClass
 
class  Hasher
 
class  PairArray
 
class  PDBMapIterator
 
class  Map
 
class  Vector
 
class  PlaceOfQueryPlanner
 
class  ProcessorFactory
 
class  QueriesAndPlan
 
class  QueryDone
 
class  QueryOutput
 
class  QueryPermit
 
class  QueryPermitResponse
 
class  RegisterReplica
 
class  RequestResources
 
class  ResourceInfo
 
class  Set
 
class  SetIdentifier
 
class  SetScan
 
class  ShutDown
 
class  SimpleRequestResult
 
class  StorageAddData
 
class  StorageAddDatabase
 
class  StorageAddObject
 
class  StorageAddObjectInLoop
 
class  StorageAddSet
 
class  StorageAddTempSet
 
class  StorageAddTempSetResult
 
class  StorageAddType
 
class  StorageBytesPinned
 
class  StorageCleanup
 
class  StorageClearSet
 
class  StorageCollectStats
 
class  StorageCollectStatsResponse
 
class  StorageExportSet
 
class  StorageGetData
 
class  StorageGetDataResponse
 
class  StorageGetSetPages
 
class  StorageNoMorePage
 
class  StoragePagePinned
 
class  StoragePinBytes
 
class  StoragePinPage
 
class  StorageRemoveDatabase
 
class  StorageRemoveHashSet
 
class  StorageRemoveTempSet
 
class  StorageRemoveUserSet
 
class  StorageTestSetCopy
 
class  StorageTestSetScan
 
class  StorageUnpinPage
 
class  StringIntPair
 
class  SumResult
 
class  Supervisor
 
class  ScoreValuePair
 
class  TopKQueue
 
class  TupleSetExecuteQuery
 
class  TupleSetJobStage
 
class  ZB_Company
 
class  PDBCommunicator
 
class  AggregateComp
 
class  AbstractAggregateComp
 
class  AbstractJoinComp
 
class  AbstractPartitionComp
 
class  AggregateCompBase
 
class  JoinArg
 
class  JoinCompBase
 
class  MultiSelectionCompBase
 
class  PartitionCompBase
 
class  PartitionTransformationCompBase
 
class  ScanUserSetBase
 
class  SelectionCompBase
 
class  WriteUserSetBase
 
class  Computation
 
class  JoinComp
 
class  MultiSelectionComp
 
class  PartitionComp
 
class  PartitionTransformationComp
 
class  ScanUserSet
 
class  SelectionComp
 
class  TopKComp
 
class  WriteUserSet
 
class  HashPartitionSink
 
class  HashPartitionTransformationSink
 
class  Partitioner
 
class  NodePartitionData
 
class  PartitionPolicy
 
class  PartitionPolicyFactory
 
class  RandomPolicy
 
class  RoundRobinPolicy
 
class  PDBDistributionManager
 
class  GenericLambdaObject
 
class  TypedLambdaObject
 
class  Lambda
 
class  AndLambda
 
class  AttAccessLambda
 
class  CPlusPlusLambda
 
class  DereferenceLambda
 
class  EqualsLambda
 
class  MethodCallLambda
 
class  SelfLambda
 
class  LambdaTree
 
class  ComputationNode
 
class  PDBClient
 
class  InactiveAllocationBlock
 
struct  AllocatorState
 
class  DummyPolicy
 
class  DefaultPolicy
 
class  NoReusePolicy
 
class  NoReferenceCountPolicy
 
class  PolicyList
 
class  NotEnoughSpace
 
class  Handle
 
class  MultiPolicyAllocator
 
class  RefCountedObject
 
class  Record
 
class  Object
 
class  String
 
class  PDBTemplateBase
 
class  UseTemporaryAllocationBlock
 
class  VTableMap
 
class  PDBLogger
 
class  PDBServer
 
class  ServerFunctionality
 
class  ServerWork
 
class  ComputeExecutor
 
class  ComputeInfo
 
class  ComputeSink
 
class  ComputeSource
 
class  FilterExecutor
 
class  FilterQueryExecutor
 
class  FlattenExecutor
 
class  HashOneExecutor
 
class  HashSink
 
struct  HasTwoArgs
 
struct  HasThreeArgs
 
struct  HasFourArgs
 
struct  HasFiveArgs
 
struct  IsAbstract
 
class  JoinTuple
 
class  JoinProbe
 
class  JoinSinkMerger
 
class  PartitionedJoinMapTupleSetIterator
 
class  JoinSinkShuffler
 
class  PartitionedJoinSink
 
class  JoinSink
 
class  JoinTupleSingleton
 
class  JoinSingleton
 
class  JoinTupleBase
 
class  MapTupleSetIterator
 
struct  MemoryHolder
 
class  Pipeline
 
class  PtrBase
 
class  Ptr
 
class  QueryExecutor
 
class  SimpleComputeExecutor
 
class  SimpleQueryExecutor
 
class  SinkMerger
 
class  SinkShuffler
 
struct  MaintenanceFuncs
 
class  TupleSet
 
class  TupleSetIterator
 
class  TupleSetSetupMachine
 
class  VectorSink
 
class  VectorTupleSetIterator
 
class  OutputIterator
 
class  Query
 
class  QueryBase
 
class  QueryClient
 
class  SetIterator
 
class  SimpleSingleTableQueryProcessor
 
class  AbstractHashSet
 
class  AbstractJobStage
 
class  AggOutProcessor
 
class  AggregationProcessor
 
class  BlockQueryProcessor
 
class  CombinedShuffleSink
 
class  CombinerProcessor
 
class  FilterBlockQueryProcessor
 
class  FilterQueryProcessor
 
class  HashSetManager
 
class  InputTupleSetSpecifier
 
class  MultiInputsBase
 
class  PartitionedHashSet
 
class  PipelineContext
 
class  PipelineStage
 
class  ProjectionBlockQueryProcessor
 
class  ProjectionQueryProcessor
 
class  SharedHashSet
 
class  ShuffleSink
 
class  StandardResourceInfo
 
class  TupleSetSpecifier
 
struct  PhysicalOptimizerResult
 
class  AbstractPhysicalNode
 
class  AbstractPhysicalNodeFactory
 
class  AdvancedPhysicalAbstractAlgorithm
 
class  AdvancedPhysicalAbstractPipe
 
class  AdvancedPhysicalNodeFactory
 
class  AdvancedPhysicalAggregationPipelineAlgorithm
 
class  AdvancedPhysicalJoinBroadcastedHashsetAlgorithm
 
class  AdvancedPhysicalPipelineAlgorithm
 
class  AdvancedPhysicalShuffledHashsetPipelineAlgorithm
 
class  AdvancedPhysicalShuffleSetAlgorithm
 
class  AdvancedPhysicalAggregationPipe
 
class  AdvancedPhysicalJoinSidePipe
 
class  AdvancedPhysicalStraightPipe
 
class  AggregationJobStageBuilder
 
class  BroadcastJoinBuildHTJobStageBuilder
 
class  HashPartitionedJoinBuildHTJobStageBuilder
 
class  TupleSetJobStageBuilder
 
class  PhysicalOptimizer
 
class  QueryGraphAnalyzer
 
class  ShuffleInfo
 
class  SimplePhysicalAggregationNode
 
class  SimplePhysicalJoinNode
 
class  SimplePhysicalNode
 
class  SimplePhysicalNodeFactory
 
class  SimplePhysicalPartitionNode
 
struct  DataStatistics
 
class  Statistics
 
class  BroadcastServer
 
class  CatalogClient
 
class  CatalogServer
 
class  DispatcherClient
 
class  DispatcherServer
 
class  DistributedStorageManagerClient
 
class  DistributedStorageManagerServer
 
class  DistributionManagerClient
 
class  DistributionManagerServer
 
class  FrontendQueryTestServer
 
class  HermesExecutionServer
 
class  PangeaStorageServer
 
class  QuerySchedulerServer
 
class  ResourceManagerServer
 
class  StorageClient
 
class  StatisticsDB
 
class  TransformedSet
 
class  SafeResult
 
class  SafeResultSuccess
 
class  SafeResultFailure
 
class  Sampler
 
class  GenericWork
 
class  NothingWork
 
class  PDBCommWork
 
class  PDBWork
 
class  PDBWorker
 
class  PDBWorkerQueue
 
class  SimpleRequestHandler
 

Typedefs

typedef std::shared_ptr
< LogicalPlan > 		LogicalPlanPtr
 
typedef std::shared_ptr
< PDBCommunicator > 		PDBCommunicatorPtr
 
typedef std::shared_ptr
< NodePartitionData > 		NodePartitionDataPtr
 
typedef std::shared_ptr
< PartitionPolicy > 		PartitionPolicyPtr
 
typedef std::shared_ptr
< RandomPolicy > 		RandomPolicyPtr
 
typedef std::shared_ptr
< RoundRobinPolicy > 		RoundRobinPolicyPtr
 
typedef shared_ptr
< PDBDistributionManager > 		PDBDistributionManagerPtr
 
typedef std::shared_ptr
< GenericLambdaObject > 		GenericLambdaObjectPtr
 
typedef MultiPolicyAllocator
< DefaultPolicy, NoReusePolicy,
NoReferenceCountPolicy > 		Allocator
 
typedef std::shared_ptr
< UseTemporaryAllocationBlock > 		UseTemporaryAllocationBlockPtr
 
typedef std::shared_ptr
< PDBLogger > 		PDBLoggerPtr
 
typedef std::shared_ptr
< PDBServer > 		PDBServerPtr
 
typedef shared_ptr< ServerWork > ServerWorkPtr
 
typedef std::shared_ptr
< ComputeExecutor > 		ComputeExecutorPtr
 
typedef std::shared_ptr
< ComputeInfo > 		ComputeInfoPtr
 
typedef std::shared_ptr
< ComputeSink > 		ComputeSinkPtr
 
typedef std::shared_ptr
< ComputeSource > 		ComputeSourcePtr
 
typedef std::shared_ptr
< JoinTupleSingleton > 		JoinTuplePtr
 
typedef std::shared_ptr
< MemoryHolder > 		MemoryHolderPtr
 
typedef std::shared_ptr< Pipeline > PipelinePtr
 
typedef std::shared_ptr
< QueryExecutor > 		QueryExecutorPtr
 
typedef std::shared_ptr
< SimpleComputeExecutor > 		SimpleComputeExecutorPtr
 
typedef std::shared_ptr
< SimpleQueryExecutor > 		SimpleQueryExecutorPtr
 
typedef std::shared_ptr
< SinkMerger > 		SinkMergerPtr
 
typedef std::shared_ptr
< SinkShuffler > 		SinkShufflerPtr
 
typedef std::shared_ptr< TupleSet > TupleSetPtr
 
using TupleSetSetupMachinePtr = std::shared_ptr< TupleSetSetupMachine >
 
typedef Handle< QueryBase > QueryBaseHdl
 
typedef std::shared_ptr
< SimpleSingleTableQueryProcessor > 		SimpleSingleTableQueryProcessorPtr
 
typedef std::shared_ptr
< AbstractHashSet > 		AbstractHashSetPtr
 
typedef std::shared_ptr
< BlockQueryProcessor > 		BlockQueryProcessorPtr
 
typedef std::shared_ptr
< PartitionedHashSet > 		PartitionedHashSetPtr
 
typedef std::shared_ptr
< PipelineContext > 		PipelineContextPtr
 
typedef std::shared_ptr
< PipelineStage > 		PipelineStagePtr
 
typedef std::shared_ptr
< SharedHashSet > 		SharedHashSetPtr
 
typedef std::shared_ptr
< StandardResourceInfo > 		StandardResourceInfoPtr
 
typedef std::shared_ptr
< PhysicalOptimizerResult > 		PhysicalOptimizerResultPtr
 
typedef std::shared_ptr
< AbstractPhysicalNode > 		AbstractPhysicalNodePtr
 
typedef std::shared_ptr
< AbstractPhysicalNode > 		AbstractPhysicalNodeWeakPtr
 
typedef std::shared_ptr
< AbstractPhysicalNodeFactory > 		AbstractPhysicalNodeFactoryPtr
 
typedef std::shared_ptr
< AdvancedPhysicalAbstractAlgorithm > 		AdvancedPhysicalAbstractAlgorithmPtr
 
typedef std::shared_ptr
< AdvancedPhysicalAbstractPipe > 		AdvancedPhysicalPipelineNodePtr
 
typedef std::shared_ptr
< AggregationJobStageBuilder > 		AggregationJobStageBuilderPtr
 
typedef std::shared_ptr
< BroadcastJoinBuildHTJobStageBuilder > 		BroadcastJoinBuildHTJobStageBuilderPtr
 
typedef std::shared_ptr
< HashPartitionedJoinBuildHTJobStageBuilder > 		HashPartitionedJoinBuildHTJobStageBuilderPtr
 
typedef std::shared_ptr
< TupleSetJobStageBuilder > 		TupleSetJobStageBuilderPtr
 
typedef std::shared_ptr
< SimplePhysicalNode > 		SimplePhysicalNodePtr
 
typedef std::shared_ptr
< SimplePhysicalNodeFactory > 		SimplePhysicalNodeFactoryPtr
 
typedef std::shared_ptr
< Statistics > 		StatisticsPtr
 
typedef shared_ptr
< DistributionManagerClient > 		DistributionManagerClientPtr
 
typedef std::shared_ptr
< PangeaStorageServer > 		PangeaStorageServerPtr
 
typedef std::shared_ptr
< PDBCommWork > 		PDBCommWorkPtr
 
typedef shared_ptr< PDBWork > PDBWorkPtr
 
typedef shared_ptr< PDBWorker > PDBWorkerPtr
 
typedef shared_ptr
< PDBWorkerQueue > 		PDBWorkerQueuePtr
 

Enumerations

enum  JoinType { HashPartitionedJoin, BroadcastJoin }
 
enum  ComputationTypeID {
  WriteUserSetTypeID, ScanUserSetTypeID, SelectionCompTypeID, PartitionCompTypeID,
  PartitionTransformationCompTypeID, AbstractPartitionCompID, AggregateCompTypeID, MultiSelectionCompTypeID,
  SetWriterTypeID, AbstractAggregateCompTypeID, ScanSetTypeID, JoinCompBaseTypeID,
  JoinCompTypeID, ClusterAggregationCompTypeID
}
 
enum  AllocatorPolicy { defaultAllocator, noReuseAllocator, noReferenceCountAllocator }
 
enum  ObjectPolicy { defaultObject, noReferenceCountObject }
 
enum  AdvancedPhysicalAbstractAlgorithmTypeID {
  SELECTION_ALGORITHM, AGGREGATION_ALGORITHM, JOIN_ALGORITHM, JOIN_BROADCASTED_HASHSET_ALGORITHM,
  JOIN_SHUFFLED_HASHSET_ALGORITHM, JOIN_SUFFLE_SET_ALGORITHM
}
 
enum  AdvancedPhysicalPipelineTypeID { STRAIGHT, JOIN_SIDE, AGGREGATION }
 

Functions

bool recurse (LogicalPlanPtr myPlan, std::vector< AtomicComputationPtr > &listSoFar, std::string &targetTupleSetName)
 
Handle< Map< String, Vector
< int > > > & 		operator+ (Handle< Map< String, Vector< int >>> &lhs, Handle< Map< String, Vector< int >>> &rhs)
 
Map< String, Vector< Handle
< Employee > > > & 		operator+ (Map< String, Vector< Handle< Employee >>> &lhs, Map< String, Vector< Handle< Employee >>> &rhs)
 
Map< String, Vector
< OptimizedEmployee > > & 		operator+ (Map< String, Vector< OptimizedEmployee >> &lhs, Map< String, Vector< OptimizedEmployee >> &rhs)
 
unsigned int newHash (unsigned int x)
 
size_t specialHash (unsigned u)
 
size_t specialHash (int u)
 
size_t hashMe (char *me, size_t len)
 
template<class RequestType , class ResponseType , class ReturnType , class... RequestTypeParams>
ReturnType compositeRequest (PDBLoggerPtr myLogger, int port, std::string address, ReturnType onErr, size_t bytesForRequest, function< ReturnType(Handle< ResponseType >, PDBCommunicator)> processResponse, RequestTypeParams &&...args)
 
template<class RequestType , class ResponseType , class ReturnType , class... RequestTypeParams>
ReturnType simpleRequest (PDBLoggerPtr myLogger, int port, std::string address, ReturnType onErr, size_t bytesForRequest, function< ReturnType(Handle< ResponseType >)> processResponse, RequestTypeParams &&...args)
 
template<class RequestType , class SecondRequestType , class ResponseType , class ReturnType >
ReturnType simpleDoubleRequest (PDBLoggerPtr myLogger, int port, std::string address, ReturnType onErr, size_t bytesForRequest, function< ReturnType(Handle< ResponseType >)> processResponse, Handle< RequestType > &firstRequest, Handle< SecondRequestType > &secondRequest)
 
template<class RequestType , class ResponseType , class ReturnType , class... RequestTypeParams>
ReturnType simpleSendBytesRequest (PDBLoggerPtr myLogger, int port, std::string address, ReturnType onErr, size_t bytesForRequest, function< ReturnType(Handle< ResponseType >)> processResponse, char *bytes, size_t numBytes, RequestTypeParams &&...args)
 
template<class RequestType , class DataType , class ResponseType , class ReturnType , class... RequestTypeParams>
ReturnType simpleSendDataRequest (PDBLoggerPtr myLogger, int port, std::string address, ReturnType onErr, size_t bytesForRequest, function< ReturnType(Handle< ResponseType >)> processResponse, Handle< Vector< DataType >> dataToSend, RequestTypeParams &&...args)
 
template<class RequestType , class DataType , class ResponseType , class ReturnType , class... RequestTypeParams>
ReturnType simpleSendObjectRequest (PDBLoggerPtr myLogger, int port, std::string address, ReturnType onErr, size_t bytesForRequest, function< ReturnType(Handle< ResponseType >)> processResponse, DataType dataToSend, RequestTypeParams &&...args)
 
template<typename LeftType , typename RightType >
LambdaTree< bool > operator&& (LambdaTree< LeftType > lhs, LambdaTree< RightType > rhs)
 
template<typename ReturnType , typename ClassType >
LambdaTree< Ptr< ReturnType > > makeLambdaUsingMember (std::string inputTypeName, std::string attName, std::string attType, Handle< ClassType > &var, ReturnType *member, size_t offset)
 
template<typename ParamOne , typename F >
auto makeLambda (Handle< ParamOne > &pOne, F arg) -> LambdaTree< std::enable_if_t< std::is_reference< decltype(arg(pOne))>::value, Ptr< typename std::remove_reference< decltype(arg(pOne))>::type >>>
 
template<typename ParamOne , typename ParamTwo , typename F >
auto makeLambda (Handle< ParamOne > &pOne, Handle< ParamTwo > &pTwo, F arg) -> LambdaTree< std::enable_if_t< std::is_reference< decltype(arg(pOne, pTwo))>::value, Ptr< typename std::remove_reference< decltype(arg(pOne, pTwo))>::type >>>
 
template<typename ParamOne , typename ParamTwo , typename ParamThree , typename F >
auto makeLambda (Handle< ParamOne > &pOne, Handle< ParamTwo > &pTwo, Handle< ParamThree > pThree, F arg) -> LambdaTree< std::enable_if_t< std::is_reference< decltype(arg(pOne, pTwo, pThree))>::value, Ptr< typename std::remove_reference< decltype(arg(pOne, pTwo, pThree))>::type >>>
 
template<typename ParamOne , typename ParamTwo , typename ParamThree , typename F >
auto makeLambda (Handle< ParamOne > &pOne, Handle< ParamTwo > &pTwo, Handle< ParamThree > &pThree, F arg) -> LambdaTree< std::enable_if_t<!std::is_reference< decltype(arg(pOne, pTwo, pThree))>::value, decltype(arg(pOne, pTwo, pThree))>>
 
template<typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename F >
auto makeLambda (Handle< ParamOne > &pOne, Handle< ParamTwo > &pTwo, Handle< ParamThree > &pThree, Handle< ParamFour > &pFour, F arg) -> LambdaTree< std::enable_if_t< std::is_reference< decltype(arg(pOne, pTwo, pThree, pFour))>::value, Ptr< typename std::remove_reference< decltype(arg(pOne, pTwo, pThree, pFour))>::type >>>
 
template<typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename ParamFive , typename F >
auto makeLambda (Handle< ParamOne > &pOne, Handle< ParamTwo > &pTwo, Handle< ParamThree > &pThree, Handle< ParamFour > &pFour, Handle< ParamFive > &pFive, F arg) -> LambdaTree< std::enable_if_t< std::is_reference< decltype(arg(pOne, pTwo, pThree, pFour, pFive))>::value, Ptr< typename std::remove_reference< decltype(arg(pOne, pTwo, pThree, pFour, pFive))>::type >>>
 
template<typename LeftType , typename RightType >
LambdaTree< bool > operator== (LambdaTree< LeftType > lhs, LambdaTree< RightType > rhs)
 
template<typename ReturnType , typename ClassType >
LambdaTree< std::enable_if_t
< std::is_reference
< ReturnType >::value, Ptr
< typename
std::remove_reference
< ReturnType >::type > > > 		makeLambdaUsingMethod (std::string inputTypeName, std::string methodName, Handle< ClassType > &var, std::string returnTypeName, ReturnType(ClassType::*arg)(), std::function< bool(std::string &, TupleSetPtr, int)> columnBuilder, std::function< SimpleComputeExecutorPtr(TupleSpec &, TupleSpec &, TupleSpec &)> getExecutor)
 
template<typename ReturnType , typename ClassType >
LambdaTree< std::enable_if_t
<!(std::is_reference
< ReturnType >::value),
ReturnType > > 		makeLambdaUsingMethod (std::string inputTypeName, std::string methodName, Handle< ClassType > &var, std::string returnTypeName, ReturnType(ClassType::*arg)(), std::function< bool(std::string &, TupleSetPtr, int)> columnBuilder, std::function< SimpleComputeExecutorPtr(TupleSpec &, TupleSpec &, TupleSpec &)> getExecutor)
 
template<bool B, typename InputType >
auto tryReference (InputType &arg) -> typename std::enable_if_t< B, InputType * >
 
template<bool B, typename InputType >
auto tryReference (InputType arg) -> typename std::enable_if_t<!B, InputType * >
 
template<typename ClassType >
LambdaTree< Ptr< ClassType > > makeLambdaFromSelf (Handle< ClassType > &var)
 
template<class LHS , class RHS >
std::enable_if_t
< std::is_base_of< PtrBase,
LHS >::value &&std::is_base_of
< PtrBase, RHS >::value, bool > 		checkAnd (LHS lhs, RHS rhs)
 
template<class LHS , class RHS >
std::enable_if_t
< std::is_base_of< PtrBase,
LHS >::value
&&!(std::is_base_of< PtrBase,
RHS >::value), bool > 		checkAnd (LHS lhs, RHS rhs)
 
template<class LHS , class RHS >
std::enable_if_t
<!(std::is_base_of< PtrBase,
LHS >::value)&&std::is_base_of
< PtrBase, RHS >::value, bool > 		checkAnd (LHS lhs, RHS rhs)
 
template<class LHS , class RHS >
std::enable_if_t
<!(std::is_base_of< PtrBase,
LHS >::value)&&!(std::is_base_of
< PtrBase, RHS >::value), bool > 		checkAnd (LHS lhs, RHS rhs)
 
template<typename F , typename ReturnType , typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename ParamFive >
std::enable_if
< !std::is_base_of< Nothing,
ParamOne >::value
&&std::is_base_of< Nothing,
ParamTwo >::value
&&std::is_base_of< Nothing,
ParamThree >::value
&&std::is_base_of< Nothing,
ParamFour >::value
&&std::is_base_of< Nothing,
ParamFive >::value, void >
::type 		callLambda (F &func, std::vector< ReturnType > &assignToMe, int which, void **args)
 
template<typename F , typename ReturnType , typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename ParamFive >
std::enable_if
< !std::is_base_of< Nothing,
ParamOne >::value
&&!std::is_base_of< Nothing,
ParamTwo >::value
&&std::is_base_of< Nothing,
ParamThree >::value
&&std::is_base_of< Nothing,
ParamFour >::value
&&std::is_base_of< Nothing,
ParamFive >::value, void >
::type 		callLambda (F &func, std::vector< ReturnType > &assignToMe, int which, void **args)
 
template<typename F , typename ReturnType , typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename ParamFive >
std::enable_if
< !std::is_base_of< Nothing,
ParamOne >::value
&&!std::is_base_of< Nothing,
ParamTwo >::value
&&!std::is_base_of< Nothing,
ParamThree >::value
&&std::is_base_of< Nothing,
ParamFour >::value
&&std::is_base_of< Nothing,
ParamFive >::value, void >
::type 		callLambda (F &func, std::vector< ReturnType > &assignToMe, int which, void **args)
 
template<typename F , typename ReturnType , typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename ParamFive >
std::enable_if
< !std::is_base_of< Nothing,
ParamOne >::value
&&!std::is_base_of< Nothing,
ParamTwo >::value
&&!std::is_base_of< Nothing,
ParamThree >::value
&&!std::is_base_of< Nothing,
ParamFour >::value
&&std::is_base_of< Nothing,
ParamFive >::value, void >
::type 		callLambda (F &func, std::vector< ReturnType > &assignToMe, int which, void **args)
 
template<typename F , typename ReturnType , typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename ParamFive >
std::enable_if
< !std::is_base_of< Nothing,
ParamOne >::value
&&!std::is_base_of< Nothing,
ParamTwo >::value
&&!std::is_base_of< Nothing,
ParamThree >::value
&&!std::is_base_of< Nothing,
ParamFour >::value
&&!std::is_base_of< Nothing,
ParamFive >::value, void >
::type 		callLambda (F &func, std::vector< ReturnType > &assignToMe, int which, void **args)
 
template<class MyType >
std::enable_if_t
< std::is_base_of< PtrBase,
MyType >::value, size_t > 		hashHim (MyType &him)
 
template<class MyType >
std::enable_if_t
<!std::is_base_of< PtrBase,
MyType >::value, size_t > 		hashHim (MyType &him)
 
template<class LHS , class RHS >
std::enable_if_t
< std::is_base_of< PtrBase,
LHS >::value &&std::is_base_of
< PtrBase, RHS >::value, bool > 		checkEquals (LHS &lhs, RHS &rhs)
 
template<class LHS , class RHS >
std::enable_if_t
< std::is_base_of< PtrBase,
LHS >::value
&&!(std::is_base_of< PtrBase,
RHS >::value), bool > 		checkEquals (LHS &lhs, RHS &rhs)
 
template<class LHS , class RHS >
std::enable_if_t
<!(std::is_base_of< PtrBase,
LHS >::value)&&std::is_base_of
< PtrBase, RHS >::value, bool > 		checkEquals (LHS &lhs, RHS &rhs)
 
template<class LHS , class RHS >
std::enable_if_t
<!(std::is_base_of< PtrBase,
LHS >::value)&&!(std::is_base_of
< PtrBase, RHS >::value), bool > 		checkEquals (LHS &lhs, RHS &rhs)
 
bool operator< (const InactiveAllocationBlock &in, const void *compToMe)
 
bool operator< (const InactiveAllocationBlock &lhs, const InactiveAllocationBlock &rhs)
 
bool operator> (const InactiveAllocationBlock &in, const void *compToMe)
 
bool operator== (const InactiveAllocationBlock &in, const void *compToMe)
 
void defaultFreeRAM (bool isContained, void *here, std::vector< InactiveAllocationBlock > &allInactives, AllocatorState &myState)
 
void * defaultGetRAM (size_t howMuch, AllocatorState &myState)
 
void * fastGetRAM (size_t howMuch, AllocatorState &myState)
 
Allocator & getAllocator ()
 
template<typename... OtherPolicies>
PolicyList< OtherPolicies...>::type first ()
 
template<typename... OtherPolicies>
std::enable_if< sizeof...(OtherPolicies)==0,
DummyPolicy >::type 		first ()
 
template<class ObjType , class ObjTypeTwo >
auto convert (ObjType *, ObjTypeTwo *) -> std::enable_if_t< std::is_base_of< ObjType, ObjTypeTwo >::value||(std::is_base_of< ObjType, Object >::value &&std::is_base_of< String, ObjTypeTwo >::value)||(std::is_base_of< ObjType, Object >::value &&std::is_base_of< HandleBase, ObjTypeTwo >::value), int >
 
template<class ObjType >
int16_t getTypeID ()
 
void makeObjectAllocatorBlock (size_t numBytesIn, bool throwExceptionOnFail)
 
void makeObjectAllocatorBlock (void *spaceToUse, size_t numBytesIn, bool throwExceptionOnFail)
 
size_t getBytesAvailableInCurrentAllocatorBlock ()
 
void emptyOutContainingBlock (void *forMe)
 
unsigned getNumObjectsInAllocatorBlock (void *forMe)
 
unsigned getNumObjectsInCurrentAllocatorBlock ()
 
template<class ObjType >
unsigned getNumObjectsInHomeAllocatorBlock (Handle< ObjType > &forMe)
 
template<class ObjType >
RefCountedObject< ObjType > * getHandle (ObjType &forMe)
 
template<class ObjType , class... Args>
RefCountedObject< ObjType > * makeObject (Args &&...args)
 
template<class ObjType , class... Args>
RefCountedObject< ObjType > * makeObjectWithExtraStorage (size_t extra, Args &&...args)
 
template<class ObjType >
Record< ObjType > * getRecord (Handle< ObjType > &forMe)
 
template<class OutObjType , class InObjType >
Handle< OutObjType > unsafeCast (Handle< InObjType > &castMe)
 
template<class ObjType >
Record< ObjType > * getRecord (Handle< ObjType > &forMe, void *putMeHere, size_t numBytesAvailable)
 
template<class TargetType >
Handle< TargetType > deepCopyToCurrentAllocationBlock (Handle< TargetType > &copyMe)
 
std::ostream & operator<< (std::ostream &stream, const String &printMe)
 
void filter (std::string &r, const char *b)
 
template<class T >
std::string getTypeName ()
 
void * callListen (void *serverInstance)
 
template<typename TypeToCallMethodOn >
auto callGetSelection (TypeToCallMethodOn &a, decltype(HasTwoArgs::test(&a))*arg=nullptr)
 
template<typename TypeToCallMethodOn >
auto callGetSelection (TypeToCallMethodOn &a, decltype(HasThreeArgs::test(&a))*arg=nullptr)
 
template<typename TypeToCallMethodOn >
auto callGetSelection (TypeToCallMethodOn &a, decltype(HasFourArgs::test(&a))*arg=nullptr)
 
template<typename TypeToCallMethodOn >
auto callGetSelection (TypeToCallMethodOn &a, decltype(HasFiveArgs::test(&a))*arg=nullptr)
 
template<typename TypeToCallMethodOn >
auto callGetProjection (TypeToCallMethodOn &a, decltype(HasTwoArgs::test(&a))*arg=nullptr)
 
template<typename TypeToCallMethodOn >
auto callGetProjection (TypeToCallMethodOn &a, decltype(HasThreeArgs::test(&a))*arg=nullptr)
 
template<typename TypeToCallMethodOn >
auto callGetProjection (TypeToCallMethodOn &a, decltype(HasFourArgs::test(&a))*arg=nullptr)
 
template<typename TypeToCallMethodOn >
auto callGetProjection (TypeToCallMethodOn &a, decltype(HasFiveArgs::test(&a))*arg=nullptr)
 
template<typename T >
void copyFrom (T &out, Handle< T > &in)
 
template<typename T >
void copyFrom (T &out, T &in)
 
template<typename T >
void copyFrom (Handle< T > &out, Handle< T > &in)
 
template<typename T >
void copyFrom (Handle< T > &out, T &in)
 
template<typename T >
void copyTo (T &out, Handle< T > &in)
 
template<typename T >
void copyTo (Handle< T > &out, Handle< T > &in)
 
template<typename TypeToCreate >
std::enable_if< sizeof(TypeToCreate::myOtherData)==0,
void >::type 		createCols (void **putUsHere, TupleSet &processMe, int offset, int whichPos, std::vector< int > positions)
 
template<typename TypeToCreate >
std::enable_if< sizeof(TypeToCreate::myOtherData)!=0,
void >::type 		createCols (void **putUsHere, TupleSet &processMe, int offset, int whichPos, std::vector< int > positions)
 
template<typename TypeToPackData >
std::enable_if<(sizeof(TypeToPackData::myOtherData)==0)&&(sizeof(TypeToPackData::myData)!=0),
void >::type 		packData (TypeToPackData &arg, TypeToPackData data)
 
template<typename TypeToPackData >
std::enable_if<(sizeof(TypeToPackData::myOtherData)!=0)&&(sizeof(TypeToPackData::myData)!=0),
void >::type 		packData (TypeToPackData &arg, TypeToPackData data)
 
template<typename TypeToPack >
std::enable_if< sizeof(TypeToPack::myOtherData)==0,
void >::type 		pack (TypeToPack &arg, int whichPosInTupleSet, int whichVec, void **us)
 
template<typename TypeToPack >
std::enable_if< sizeof(TypeToPack::myOtherData)!=0,
void >::type 		pack (TypeToPack &arg, int whichPosInTupleSet, int whichVec, void **us)
 
template<typename TypeToUnPack >
std::enable_if< sizeof(TypeToUnPack::myOtherData)==0,
void >::type 		unpack (TypeToUnPack &arg, int whichPosInTupleSet, int whichVec, void **us)
 
template<typename TypeToUnPack >
std::enable_if< sizeof(TypeToUnPack::myOtherData)!=0,
void >::type 		unpack (TypeToUnPack &arg, int whichPosInTupleSet, int whichVec, void **us)
 
template<typename TypeToTruncate >
std::enable_if< sizeof(TypeToTruncate::myOtherData)==0,
void >::type 		eraseEnd (int i, int whichVec, void **us)
 
template<typename TypeToTruncate >
std::enable_if< sizeof(TypeToTruncate::myOtherData)!=0,
void >::type 		eraseEnd (int i, int whichVec, void **us)
 
template<typename TypeToTruncate >
std::enable_if< sizeof(TypeToTruncate::myOtherData)==0,
void >::type 		truncate (int i, int whichVec, void **us)
 
template<typename TypeToTruncate >
std::enable_if< sizeof(TypeToTruncate::myOtherData)!=0,
void >::type 		truncate (int i, int whichVec, void **us)
 
int findType (std::string &findMe, std::vector< std::string > &typeList)
 
template<typename In1 >
std::enable_if
< std::is_base_of
< JoinTupleBase, In1 >::value,
JoinTuplePtr >::type 		findCorrectJoinTuple (std::vector< std::string > &typeList, std::vector< int > &whereEveryoneGoes)
 
template<typename In1 , typename... Rest>
std::enable_if< sizeof...(Rest)!=0
&&!std::is_base_of
< JoinTupleBase, In1 >::value,
JoinTuplePtr >::type 		findCorrectJoinTuple (std::vector< std::string > &typeList, std::vector< int > &whereEveryoneGoes)
 
template<typename In1 , typename In2 , typename... Rest>
std::enable_if
< std::is_base_of
< JoinTupleBase, In1 >::value,
JoinTuplePtr >::type 		findCorrectJoinTuple (std::vector< std::string > &typeList, std::vector< int > &whereEveryoneGoes)
 
template<typename In1 >
std::enable_if
<!std::is_base_of
< JoinTupleBase, In1 >::value,
JoinTuplePtr >::type 		findCorrectJoinTuple (std::vector< std::string > &typeList, std::vector< int > &whereEveryoneGoes)
 
template<bool B, typename InputType >
auto tryDereference (InputType &arg) -> typename std::enable_if_t< B, decltype(*arg)& >
 
template<bool B, typename InputType >
auto tryDereference (InputType &&arg) -> typename std::enable_if_t<!B, InputType & >
 
template<bool B, typename InputType >
auto getSerializedSize () -> typename std::enable_if_t< B, size_t >
 
template<bool B, typename InputType >
auto tryToObtainPointer (InputType &arg) -> typename std::enable_if_t< B, InputType * >
 
void * enterTheQueue (void *pdbWorkerQueueInstance)
 

Variables

void * someRandomPointer
 
void * stackBase
 
void * stackEnd
 
Allocator * mainAllocatorPtr
 
NotEnoughSpace myException
 
bool inSharedLibrary
 
VTableMap * theVTable
 
GenericHandle foofoo
 

Detailed Description

This class encapsulates the place of the query planner.

This message is sent when the query executor node is done with processing of query.

This class encapsulates the response to running a query request.

This class encapsulates the permission request for running a query on distributed PDB cluster.

This class is used to encapsulate the inner workings of the aggregate computation. Do not derive from this class, when crating compute plans!

The basic idea is that we have a "class Lambda <typename Out>" that is returned by the query object.

This class provides functionality so users can connect and access different Server functionalities of PDB, such as:

Catalog services Dispatcher services Distributed Storage services Query services

Class for handling requests regarding the Catalog Server functionality. This can be used either by the Catalog Manager Server or a Catalog in any Worker Node in the cluster. All metadata is stored and retrieved via the pdbCatalog class, which has an SQLite database as the underlying persistent storage.

If this is the manager catalog server, it will receive a metadata registration request and perform the following operations:

1) update metadata in the local manager catalog SQLite database 2) iterate over all registered nodes in the cluster and send the metadata object 3) update catalog version

if this is the catalog instance of a worker node, it will receive a metadata registration request from the manager catalog server and perform the following operations:

1) update metadata in the local catalog SQLite database 2) update catalog version 3) send acknowledgement to manager catalog server

Typedef Documentation

typedef std::shared_ptr<AbstractHashSet> pdb::AbstractHashSetPtr

Definition at line 26 of file AbstractHashSet.h.

typedef std::shared_ptr<AbstractPhysicalNodeFactory> pdb::AbstractPhysicalNodeFactoryPtr

Definition at line 27 of file AbstractPhysicalNodeFactory.h.

typedef std::shared_ptr<AbstractPhysicalNode> pdb::AbstractPhysicalNodePtr

Definition at line 39 of file AbstractPhysicalNode.h.

typedef std::shared_ptr<AbstractPhysicalNode> pdb::AbstractPhysicalNodeWeakPtr

Definition at line 40 of file AbstractPhysicalNode.h.

typedef std::shared_ptr< AdvancedPhysicalAbstractAlgorithm > pdb::AdvancedPhysicalAbstractAlgorithmPtr

Definition at line 36 of file AdvancedPhysicalAbstractAlgorithm.h.

typedef std::shared_ptr<AdvancedPhysicalAbstractPipe> pdb::AdvancedPhysicalPipelineNodePtr

Definition at line 35 of file AdvancedPhysicalAbstractPipe.h.

typedef std::shared_ptr<AggregationJobStageBuilder> pdb::AggregationJobStageBuilderPtr

Definition at line 27 of file AggregationJobStageBuilder.h.

typedef MultiPolicyAllocator<DefaultPolicy, NoReusePolicy, NoReferenceCountPolicy> pdb::Allocator

Definition at line 522 of file Allocator.h.

typedef std::shared_ptr<BlockQueryProcessor> pdb::BlockQueryProcessorPtr

Definition at line 28 of file BlockQueryProcessor.h.

typedef std::shared_ptr<BroadcastJoinBuildHTJobStageBuilder> pdb::BroadcastJoinBuildHTJobStageBuilderPtr

Definition at line 26 of file BroadcastJoinBuildHTJobStageBuilder.h.

typedef std::shared_ptr<ComputeExecutor> pdb::ComputeExecutorPtr

Definition at line 27 of file ComputeExecutor.h.

typedef std::shared_ptr<ComputeInfo> pdb::ComputeInfoPtr

Definition at line 33 of file ComputeInfo.h.

typedef std::shared_ptr<ComputeSink> pdb::ComputeSinkPtr

Definition at line 27 of file ComputeSink.h.

typedef std::shared_ptr<ComputeSource> pdb::ComputeSourcePtr

Definition at line 26 of file ComputeSource.h.

typedef shared_ptr<DistributionManagerClient> pdb::DistributionManagerClientPtr

Definition at line 40 of file DistributionManagerClient.h.

typedef std::shared_ptr<GenericLambdaObject> pdb::GenericLambdaObjectPtr

Definition at line 48 of file GenericLambdaObject.h.

typedef std::shared_ptr<HashPartitionedJoinBuildHTJobStageBuilder> pdb::HashPartitionedJoinBuildHTJobStageBuilderPtr

Definition at line 25 of file HashPartitionedJoinBuildHTJobStageBuilder.h.

typedef std::shared_ptr<JoinTupleSingleton> pdb::JoinTuplePtr

Definition at line 1251 of file JoinTuple.h.

typedef std::shared_ptr<LogicalPlan> pdb::LogicalPlanPtr

Definition at line 36 of file ComputePlan.h.

typedef std::shared_ptr<MemoryHolder> pdb::MemoryHolderPtr

Definition at line 61 of file Pipeline.h.

typedef std::shared_ptr<NodePartitionData> pdb::NodePartitionDataPtr

Definition at line 29 of file NodePartitionData.h.

typedef std::shared_ptr<PangeaStorageServer> pdb::PangeaStorageServerPtr

Definition at line 46 of file PangeaStorageServer.h.

typedef std::shared_ptr<PartitionedHashSet> pdb::PartitionedHashSetPtr

Definition at line 27 of file PartitionedHashSet.h.

typedef std::shared_ptr<PartitionPolicy> pdb::PartitionPolicyPtr

Definition at line 34 of file PartitionPolicy.h.

typedef std::shared_ptr<PDBCommunicator> pdb::PDBCommunicatorPtr

Definition at line 40 of file PDBCommunicator.h.

typedef std::shared_ptr<PDBCommWork> pdb::PDBCommWorkPtr

Definition at line 37 of file PDBCommWork.h.

typedef shared_ptr<PDBDistributionManager> pdb::PDBDistributionManagerPtr

Definition at line 55 of file PDBDistributionManager.h.

typedef std::shared_ptr<PDBLogger> pdb::PDBLoggerPtr

Definition at line 40 of file PDBLogger.h.

typedef std::shared_ptr<PDBServer> pdb::PDBServerPtr

Definition at line 32 of file PDBServer.h.

typedef shared_ptr< PDBWorker > pdb::PDBWorkerPtr

Definition at line 40 of file PDBWorker.h.

typedef shared_ptr<PDBWorkerQueue> pdb::PDBWorkerQueuePtr

Definition at line 42 of file PDBWorkerQueue.h.

typedef shared_ptr< PDBWork > pdb::PDBWorkPtr

Definition at line 47 of file PDBWork.h.

typedef std::shared_ptr<PhysicalOptimizerResult> pdb::PhysicalOptimizerResultPtr

Definition at line 36 of file AbstractPhysicalNode.h.

typedef std::shared_ptr<PipelineContext> pdb::PipelineContextPtr

Definition at line 33 of file PipelineContext.h.

typedef std::shared_ptr<Pipeline> pdb::PipelinePtr

Definition at line 314 of file Pipeline.h.

typedef std::shared_ptr<PipelineStage> pdb::PipelineStagePtr

Definition at line 45 of file PipelineStage.h.

typedef Handle<QueryBase> pdb::QueryBaseHdl

Definition at line 183 of file QueryBase.h.

typedef std::shared_ptr<QueryExecutor> pdb::QueryExecutorPtr

Definition at line 27 of file QueryExecutor.h.

typedef std::shared_ptr<RandomPolicy> pdb::RandomPolicyPtr

Definition at line 31 of file RandomPolicy.h.

typedef std::shared_ptr<RoundRobinPolicy> pdb::RoundRobinPolicyPtr

Definition at line 29 of file RoundRobinPolicy.h.

typedef shared_ptr<ServerWork> pdb::ServerWorkPtr

Definition at line 36 of file ServerWork.h.

typedef std::shared_ptr<SharedHashSet> pdb::SharedHashSetPtr

Definition at line 26 of file SharedHashSet.h.

typedef std::shared_ptr<SimpleComputeExecutor> pdb::SimpleComputeExecutorPtr

Definition at line 28 of file SimpleComputeExecutor.h.

typedef std::shared_ptr<SimplePhysicalNodeFactory> pdb::SimplePhysicalNodeFactoryPtr

Definition at line 25 of file SimplePhysicalNodeFactory.h.

typedef std::shared_ptr<SimplePhysicalNode> pdb::SimplePhysicalNodePtr

Definition at line 30 of file SimplePhysicalNode.h.

typedef std::shared_ptr<SimpleQueryExecutor> pdb::SimpleQueryExecutorPtr

Definition at line 28 of file SimpleQueryExecutor.h.

typedef std::shared_ptr<SimpleSingleTableQueryProcessor> pdb::SimpleSingleTableQueryProcessorPtr

Definition at line 27 of file SimpleSingleTableQueryProcessor.h.

typedef std::shared_ptr<SinkMerger> pdb::SinkMergerPtr

Definition at line 30 of file SinkMerger.h.

typedef std::shared_ptr<SinkShuffler> pdb::SinkShufflerPtr

Definition at line 31 of file SinkShuffler.h.

typedef std::shared_ptr<StandardResourceInfo> pdb::StandardResourceInfoPtr

Definition at line 25 of file StandardResourceInfo.h.

typedef std::shared_ptr<Statistics> pdb::StatisticsPtr

Definition at line 27 of file Statistics.h.

typedef std::shared_ptr<TupleSetJobStageBuilder> pdb::TupleSetJobStageBuilderPtr

Definition at line 26 of file TupleSetJobStageBuilder.h.

typedef std::shared_ptr<TupleSet> pdb::TupleSetPtr

Definition at line 64 of file TupleSet.h.

using pdb::TupleSetSetupMachinePtr = typedef std::shared_ptr<TupleSetSetupMachine>

Definition at line 94 of file TupleSetMachine.h.

typedef std::shared_ptr<UseTemporaryAllocationBlock> pdb::UseTemporaryAllocationBlockPtr

Definition at line 28 of file UseTemporaryAllocationBlock.h.

Enumeration Type Documentation

enum pdb::AdvancedPhysicalAbstractAlgorithmTypeID
Enumerator
SELECTION_ALGORITHM 
AGGREGATION_ALGORITHM 
JOIN_ALGORITHM 
JOIN_BROADCASTED_HASHSET_ALGORITHM 
JOIN_SHUFFLED_HASHSET_ALGORITHM 
JOIN_SUFFLE_SET_ALGORITHM 

Definition at line 27 of file AdvancedPhysicalAbstractAlgorithm.h.

enum pdb::AdvancedPhysicalPipelineTypeID

The possible types of the pipelines in this algorithms

Enumerator
STRAIGHT 
JOIN_SIDE 
AGGREGATION 

Definition at line 41 of file AdvancedPhysicalAbstractPipe.h.

enum pdb::AllocatorPolicy
Enumerator
defaultAllocator 
noReuseAllocator 
noReferenceCountAllocator 

Definition at line 130 of file Allocator.h.

enum pdb::ComputationTypeID

List all the possible computation types

Enumerator
WriteUserSetTypeID 
ScanUserSetTypeID 
SelectionCompTypeID 
PartitionCompTypeID 
PartitionTransformationCompTypeID 
AbstractPartitionCompID 
AggregateCompTypeID 
MultiSelectionCompTypeID 
SetWriterTypeID 
AbstractAggregateCompTypeID 
ScanSetTypeID 
JoinCompBaseTypeID 
JoinCompTypeID 
ClusterAggregationCompTypeID 

Definition at line 39 of file Computation.h.

enum pdb::JoinType

The possible types of joins

Enumerator
HashPartitionedJoin 
BroadcastJoin 

Definition at line 51 of file JoinCompBase.h.

enum pdb::ObjectPolicy
Enumerator
defaultObject 
noReferenceCountObject 

Definition at line 34 of file Object.h.

Function Documentation

template<typename TypeToCallMethodOn >
auto pdb::callGetProjection ( TypeToCallMethodOn &  a,
decltype(HasTwoArgs::test(&a))*  arg = nullptr 
)

Definition at line 93 of file JoinTests.h.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

template<typename TypeToCallMethodOn >
auto pdb::callGetProjection ( TypeToCallMethodOn &  a,
decltype(HasThreeArgs::test(&a))*  arg = nullptr 
)

Definition at line 100 of file JoinTests.h.

+ Here is the call graph for this function:

template<typename TypeToCallMethodOn >
auto pdb::callGetProjection ( TypeToCallMethodOn &  a,
decltype(HasFourArgs::test(&a))*  arg = nullptr 
)

Definition at line 108 of file JoinTests.h.

+ Here is the call graph for this function:

template<typename TypeToCallMethodOn >
auto pdb::callGetProjection ( TypeToCallMethodOn &  a,
decltype(HasFiveArgs::test(&a))*  arg = nullptr 
)

Definition at line 117 of file JoinTests.h.

+ Here is the call graph for this function:

template<typename TypeToCallMethodOn >
auto pdb::callGetSelection ( TypeToCallMethodOn &  a,
decltype(HasTwoArgs::test(&a))*  arg = nullptr 
)

Definition at line 59 of file JoinTests.h.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

template<typename TypeToCallMethodOn >
auto pdb::callGetSelection ( TypeToCallMethodOn &  a,
decltype(HasThreeArgs::test(&a))*  arg = nullptr 
)

Definition at line 66 of file JoinTests.h.

+ Here is the call graph for this function:

template<typename TypeToCallMethodOn >
auto pdb::callGetSelection ( TypeToCallMethodOn &  a,
decltype(HasFourArgs::test(&a))*  arg = nullptr 
)

Definition at line 74 of file JoinTests.h.

+ Here is the call graph for this function:

template<typename TypeToCallMethodOn >
auto pdb::callGetSelection ( TypeToCallMethodOn &  a,
decltype(HasFiveArgs::test(&a))*  arg = nullptr 
)

Definition at line 83 of file JoinTests.h.

+ Here is the call graph for this function:

template<typename F , typename ReturnType , typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename ParamFive >
std::enable_if< !std::is_base_of<Nothing, ParamOne>::value && std::is_base_of<Nothing, ParamTwo>::value && std::is_base_of<Nothing, ParamThree>::value && std::is_base_of<Nothing, ParamFour>::value && std::is_base_of<Nothing, ParamFive>::value, void>::type pdb::callLambda ( F &  func,
std::vector< ReturnType > &  assignToMe,
int  which,
void **  args 
)

Definition at line 42 of file CPlusPlusLambda.h.

template<typename F , typename ReturnType , typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename ParamFive >
std::enable_if< !std::is_base_of<Nothing, ParamOne>::value && !std::is_base_of<Nothing, ParamTwo>::value && std::is_base_of<Nothing, ParamThree>::value && std::is_base_of<Nothing, ParamFour>::value && std::is_base_of<Nothing, ParamFive>::value, void>::type pdb::callLambda ( F &  func,
std::vector< ReturnType > &  assignToMe,
int  which,
void **  args 
)

Definition at line 58 of file CPlusPlusLambda.h.

template<typename F , typename ReturnType , typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename ParamFive >
std::enable_if< !std::is_base_of<Nothing, ParamOne>::value && !std::is_base_of<Nothing, ParamTwo>::value && !std::is_base_of<Nothing, ParamThree>::value && std::is_base_of<Nothing, ParamFour>::value && std::is_base_of<Nothing, ParamFive>::value, void>::type pdb::callLambda ( F &  func,
std::vector< ReturnType > &  assignToMe,
int  which,
void **  args 
)

Definition at line 74 of file CPlusPlusLambda.h.

template<typename F , typename ReturnType , typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename ParamFive >
std::enable_if< !std::is_base_of<Nothing, ParamOne>::value && !std::is_base_of<Nothing, ParamTwo>::value && !std::is_base_of<Nothing, ParamThree>::value && !std::is_base_of<Nothing, ParamFour>::value && std::is_base_of<Nothing, ParamFive>::value, void>::type pdb::callLambda ( F &  func,
std::vector< ReturnType > &  assignToMe,
int  which,
void **  args 
)

Definition at line 90 of file CPlusPlusLambda.h.

template<typename F , typename ReturnType , typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename ParamFive >
std::enable_if< !std::is_base_of<Nothing, ParamOne>::value && !std::is_base_of<Nothing, ParamTwo>::value && !std::is_base_of<Nothing, ParamThree>::value && !std::is_base_of<Nothing, ParamFour>::value && !std::is_base_of<Nothing, ParamFive>::value, void>::type pdb::callLambda ( F &  func,
std::vector< ReturnType > &  assignToMe,
int  which,
void **  args 
)

Definition at line 107 of file CPlusPlusLambda.h.

void* pdb::callListen ( void *  serverInstance)

Definition at line 87 of file PDBServer.cc.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

template<class LHS , class RHS >
std::enable_if_t<std::is_base_of<PtrBase, LHS>::value && std::is_base_of<PtrBase, RHS>::value, bool> pdb::checkAnd ( LHS  lhs,
RHS  rhs 
)

Definition at line 35 of file AndLambda.h.

+ Here is the caller graph for this function:

template<class LHS , class RHS >
std::enable_if_t<std::is_base_of<PtrBase, LHS>::value && !(std::is_base_of<PtrBase, RHS>::value), bool> pdb::checkAnd ( LHS  lhs,
RHS  rhs 
)

Definition at line 42 of file AndLambda.h.

template<class LHS , class RHS >
std::enable_if_t<!(std::is_base_of<PtrBase, LHS>::value) && std::is_base_of<PtrBase, RHS>::value, bool> pdb::checkAnd ( LHS  lhs,
RHS  rhs 
)

Definition at line 49 of file AndLambda.h.

template<class LHS , class RHS >
std::enable_if_t<!(std::is_base_of<PtrBase, LHS>::value) && !(std::is_base_of<PtrBase, RHS>::value), bool> pdb::checkAnd ( LHS  lhs,
RHS  rhs 
)

Definition at line 56 of file AndLambda.h.

template<class LHS , class RHS >
std::enable_if_t<std::is_base_of<PtrBase, LHS>::value && std::is_base_of<PtrBase, RHS>::value, bool> pdb::checkEquals ( LHS &  lhs,
RHS &  rhs 
)

Definition at line 49 of file EqualsLambda.h.

+ Here is the caller graph for this function:

template<class LHS , class RHS >
std::enable_if_t<std::is_base_of<PtrBase, LHS>::value && !(std::is_base_of<PtrBase, RHS>::value), bool> pdb::checkEquals ( LHS &  lhs,
RHS &  rhs 
)

Definition at line 58 of file EqualsLambda.h.

template<class LHS , class RHS >
std::enable_if_t<!(std::is_base_of<PtrBase, LHS>::value) && std::is_base_of<PtrBase, RHS>::value, bool> pdb::checkEquals ( LHS &  lhs,
RHS &  rhs 
)

Definition at line 67 of file EqualsLambda.h.

template<class LHS , class RHS >
std::enable_if_t<!(std::is_base_of<PtrBase, LHS>::value) && !(std::is_base_of<PtrBase, RHS>::value), bool> pdb::checkEquals ( LHS &  lhs,
RHS &  rhs 
)

Definition at line 76 of file EqualsLambda.h.

template<class RequestType , class ResponseType , class ReturnType , class... RequestTypeParams>
ReturnType pdb::compositeRequest ( PDBLoggerPtr  myLogger,
int  port,
std::string  address,
ReturnType  onErr,
size_t  bytesForRequest,
function< ReturnType(Handle< ResponseType >, PDBCommunicator)>  processResponse,
RequestTypeParams &&...  args 
)

Definition at line 28 of file CompositeRequest.cc.

+ Here is the call graph for this function:

template<class ObjType , class ObjTypeTwo >
auto pdb::convert ( ObjType *  ,
ObjTypeTwo *   
) -> std::enable_if_t< std::is_base_of<ObjType, ObjTypeTwo>::value || (std::is_base_of<ObjType, Object>::value && std::is_base_of<String, ObjTypeTwo>::value) || (std::is_base_of<ObjType, Object>::value && std::is_base_of<HandleBase, ObjTypeTwo>::value), int>

Definition at line 266 of file Handle.cc.

template<typename T >
void pdb::copyFrom ( T &  out,
Handle< T > &  in 
)

Definition at line 32 of file JoinTuple.h.

+ Here is the caller graph for this function:

template<typename T >
void pdb::copyFrom ( T &  out,
T &  in 
)

Definition at line 37 of file JoinTuple.h.

template<typename T >
void pdb::copyFrom ( Handle< T > &  out,
Handle< T > &  in 
)

Definition at line 42 of file JoinTuple.h.

template<typename T >
void pdb::copyFrom ( Handle< T > &  out,
T &  in 
)

Definition at line 47 of file JoinTuple.h.

template<typename T >
void pdb::copyTo ( T &  out,
Handle< T > &  in 
)

Definition at line 52 of file JoinTuple.h.

+ Here is the caller graph for this function:

template<typename T >
void pdb::copyTo ( Handle< T > &  out,
Handle< T > &  in 
)

Definition at line 59 of file JoinTuple.h.

template<typename TypeToCreate >
std::enable_if<sizeof(TypeToCreate::myOtherData) == 0, void>::type pdb::createCols ( void **  putUsHere,
TupleSet &  processMe,
int  offset,
int  whichPos,
std::vector< int >  positions 
)

Definition at line 145 of file JoinTuple.h.

template<typename TypeToCreate >
std::enable_if<sizeof(TypeToCreate::myOtherData) != 0, void>::type pdb::createCols ( void **  putUsHere,
TupleSet &  processMe,
int  offset,
int  whichPos,
std::vector< int >  positions 
)

Definition at line 152 of file JoinTuple.h.

template<class TargetType >
Handle< TargetType > pdb::deepCopyToCurrentAllocationBlock ( Handle< TargetType > &  copyMe)

Definition at line 306 of file InterfaceFunctions.cc.

+ Here is the caller graph for this function:

void pdb::defaultFreeRAM ( bool  isContained,
void *  here,
std::vector< InactiveAllocationBlock > &  allInactives,
AllocatorState &  myState 
)
inline

Definition at line 118 of file Allocator.cc.

+ Here is the caller graph for this function:

void* pdb::defaultGetRAM ( size_t  howMuch,
AllocatorState &  myState 
)
inline

Definition at line 196 of file Allocator.cc.

+ Here is the caller graph for this function:

void pdb::emptyOutContainingBlock ( void *  forMe)
inline

Definition at line 91 of file InterfaceFunctions.cc.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void* pdb::enterTheQueue ( void *  pdbWorkerQueueInstance)

Definition at line 156 of file PDBWorkerQueue.cc.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

template<typename TypeToTruncate >
std::enable_if<sizeof(TypeToTruncate::myOtherData) == 0, void>::type pdb::eraseEnd ( int  i,
int  whichVec,
void **  us 
)

Definition at line 233 of file JoinTuple.h.

+ Here is the call graph for this function:

template<typename TypeToTruncate >
std::enable_if<sizeof(TypeToTruncate::myOtherData) != 0, void>::type pdb::eraseEnd ( int  i,
int  whichVec,
void **  us 
)

Definition at line 242 of file JoinTuple.h.

+ Here is the caller graph for this function:

void* pdb::fastGetRAM ( size_t  howMuch,
AllocatorState &  myState 
)
inline

Definition at line 285 of file Allocator.cc.

+ Here is the caller graph for this function:

void pdb::filter ( std::string &  r,
const char *  b 
)
inline

Definition at line 20 of file TypeName.cc.

+ Here is the caller graph for this function:

template<typename In1 >
std::enable_if< std::is_base_of< JoinTupleBase, In1 >::value, JoinTuplePtr >::type pdb::findCorrectJoinTuple ( std::vector< std::string > &  typeList,
std::vector< int > &  whereEveryoneGoes 
)

Definition at line 1301 of file JoinTuple.h.

+ Here is the caller graph for this function:

template<typename In1 , typename... Rest>
std::enable_if< sizeof...(Rest)!=0 &&!std::is_base_of< JoinTupleBase, In1 >::value, JoinTuplePtr >::type pdb::findCorrectJoinTuple ( std::vector< std::string > &  typeList,
std::vector< int > &  whereEveryoneGoes 
)

Definition at line 1308 of file JoinTuple.h.

+ Here is the call graph for this function:

template<typename In1 , typename In2 , typename... Rest>
std::enable_if< std::is_base_of< JoinTupleBase, In1 >::value, JoinTuplePtr >::type pdb::findCorrectJoinTuple ( std::vector< std::string > &  typeList,
std::vector< int > &  whereEveryoneGoes 
)

Definition at line 1328 of file JoinTuple.h.

+ Here is the call graph for this function:

template<typename In1 >
std::enable_if<!std::is_base_of< JoinTupleBase, In1 >::value, JoinTuplePtr >::type pdb::findCorrectJoinTuple ( std::vector< std::string > &  typeList,
std::vector< int > &  whereEveryoneGoes 
)

Definition at line 1282 of file JoinTuple.h.

+ Here is the call graph for this function:

int pdb::findType ( std::string &  findMe,
std::vector< std::string > &  typeList 
)
inline

Definition at line 1253 of file JoinTuple.h.

+ Here is the caller graph for this function:

template<typename... OtherPolicies>
PolicyList<OtherPolicies...> ::type pdb::first ( )

+ Here is the caller graph for this function:

template<typename... OtherPolicies>
std::enable_if<sizeof...(OtherPolicies) == 0, DummyPolicy>::type pdb::first ( )
Allocator & pdb::getAllocator ( )
inline

Definition at line 943 of file Allocator.cc.

+ Here is the caller graph for this function:

size_t pdb::getBytesAvailableInCurrentAllocatorBlock ( )
inline

Definition at line 87 of file InterfaceFunctions.cc.

+ Here is the call graph for this function:

template<class ObjType >
RefCountedObject< ObjType > * pdb::getHandle ( ObjType &  forMe)

Definition at line 109 of file InterfaceFunctions.cc.

+ Here is the call graph for this function:

unsigned pdb::getNumObjectsInAllocatorBlock ( void *  forMe)
inline

Definition at line 95 of file InterfaceFunctions.cc.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

unsigned pdb::getNumObjectsInCurrentAllocatorBlock ( )
inline

Definition at line 99 of file InterfaceFunctions.cc.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

template<class ObjType >
unsigned pdb::getNumObjectsInHomeAllocatorBlock ( Handle< ObjType > &  forMe)

Definition at line 104 of file InterfaceFunctions.cc.

+ Here is the call graph for this function:

template<class ObjType >
Record< ObjType > * pdb::getRecord ( Handle< ObjType > &  forMe)

Definition at line 251 of file InterfaceFunctions.cc.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

template<class ObjType >
Record< ObjType > * pdb::getRecord ( Handle< ObjType > &  forMe,
void *  putMeHere,
size_t  numBytesAvailable 
)

Definition at line 275 of file InterfaceFunctions.cc.

+ Here is the call graph for this function:

template<bool B, typename InputType >
auto pdb::getSerializedSize ( ) -> typename std::enable_if_t<B, size_t>

Definition at line 42 of file TupleSet.h.

+ Here is the caller graph for this function:

template<class ObjType >
int16_t pdb::getTypeID ( )

Definition at line 42 of file InterfaceFunctions.cc.

+ Here is the call graph for this function:

template<class T >
std::string pdb::getTypeName ( )

Definition at line 38 of file TypeName.cc.

+ Here is the call graph for this function:

template<class MyType >
std::enable_if_t<std::is_base_of<PtrBase, MyType>::value, size_t> pdb::hashHim ( MyType &  him)

Definition at line 36 of file EqualsLambda.h.

+ Here is the caller graph for this function:

template<class MyType >
std::enable_if_t<!std::is_base_of<PtrBase, MyType>::value, size_t> pdb::hashHim ( MyType &  him)

Definition at line 41 of file EqualsLambda.h.

+ Here is the call graph for this function:

size_t pdb::hashMe ( char *  me,
size_t  len 
)
inline

Definition at line 36 of file PDBMap.cc.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

template<typename ParamOne , typename F >
auto pdb::makeLambda ( Handle< ParamOne > &  pOne,
F  arg 
) -> LambdaTree<std::enable_if_t<std::is_reference<decltype(arg(pOne))>::value, Ptr<typename std::remove_reference<decltype(arg(pOne))>::type>>>

these next ten functions are used to create PDB Lambdas out of C++ lambdas // TODO add proper description

Template Parameters
ParamOne// TODO add proper description
F// TODO add proper description
Parameters
pOne// TODO add proper description
arg// TODO add proper description
Returns
// TODO add proper description

// TODO add proper description

Template Parameters
ParamOne// TODO add proper description
F// TODO add proper description
Parameters
pOne// TODO add proper description
arg// TODO add proper description
Returns
// TODO add proper description

Definition at line 48 of file CPPLambdaCreationFunctions.h.

+ Here is the caller graph for this function:

template<typename ParamOne , typename ParamTwo , typename F >
auto pdb::makeLambda ( Handle< ParamOne > &  pOne,
Handle< ParamTwo > &  pTwo,
F  arg 
) -> LambdaTree<std::enable_if_t<std::is_reference<decltype(arg(pOne, pTwo))>::value, Ptr<typename std::remove_reference<decltype(arg(pOne, pTwo))>::type>>>

// TODO add proper description

Template Parameters
ParamOne// TODO add proper description
ParamTwo// TODO add proper description
F// TODO add proper description
Parameters
pOne// TODO add proper description
pTwo// TODO add proper description
arg// TODO add proper description
Returns
// TODO add proper description

Definition at line 85 of file CPPLambdaCreationFunctions.h.

template<typename ParamOne , typename ParamTwo , typename ParamThree , typename F >
auto pdb::makeLambda ( Handle< ParamOne > &  pOne,
Handle< ParamTwo > &  pTwo,
Handle< ParamThree >  pThree,
F  arg 
) -> LambdaTree<std::enable_if_t<std::is_reference<decltype(arg(pOne, pTwo, pThree))>::value, Ptr<typename std::remove_reference<decltype(arg(pOne, pTwo, pThree))>::type>>>

// TODO add proper description

Template Parameters
ParamOne// TODO add proper description
ParamTwo// TODO add proper description
ParamThree// TODO add proper description
F// TODO add proper description
Parameters
pOne// TODO add proper description
pTwo// TODO add proper description
pThree// TODO add proper description
arg// TODO add proper description
Returns
// TODO add proper description

Definition at line 126 of file CPPLambdaCreationFunctions.h.

template<typename ParamOne , typename ParamTwo , typename ParamThree , typename F >
auto pdb::makeLambda ( Handle< ParamOne > &  pOne,
Handle< ParamTwo > &  pTwo,
Handle< ParamThree > &  pThree,
F  arg 
) -> LambdaTree<std::enable_if_t<!std::is_reference<decltype(arg(pOne, pTwo, pThree))>::value, decltype(arg(pOne, pTwo, pThree))>>

// TODO add proper description

Template Parameters
ParamOne// TODO add proper description
ParamTwo// TODO add proper description
ParamThree// TODO add proper description
F// TODO add proper description
Parameters
pOne// TODO add proper description
pTwo// TODO add proper description
pThree// TODO add proper description
arg// TODO add proper description
Returns
// TODO add proper description

Definition at line 150 of file CPPLambdaCreationFunctions.h.

template<typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename F >
auto pdb::makeLambda ( Handle< ParamOne > &  pOne,
Handle< ParamTwo > &  pTwo,
Handle< ParamThree > &  pThree,
Handle< ParamFour > &  pFour,
F  arg 
) -> LambdaTree<std::enable_if_t<std::is_reference<decltype(arg(pOne, pTwo, pThree, pFour))>::value, Ptr<typename std::remove_reference<decltype(arg(pOne, pTwo, pThree, pFour))>::type>>>

// TODO add proper description

Template Parameters
ParamOne// TODO add proper description
ParamTwo// TODO add proper description
ParamThree// TODO add proper description
ParamFour// TODO add proper description
F// TODO add proper description
Parameters
pOne// TODO add proper description
pTwo// TODO add proper description
pThree// TODO add proper description
pFour// TODO add proper description
arg// TODO add proper description
Returns
// TODO add proper description

Definition at line 175 of file CPPLambdaCreationFunctions.h.

template<typename ParamOne , typename ParamTwo , typename ParamThree , typename ParamFour , typename ParamFive , typename F >
auto pdb::makeLambda ( Handle< ParamOne > &  pOne,
Handle< ParamTwo > &  pTwo,
Handle< ParamThree > &  pThree,
Handle< ParamFour > &  pFour,
Handle< ParamFive > &  pFive,
F  arg 
) -> LambdaTree<std::enable_if_t<std::is_reference<decltype(arg(pOne, pTwo, pThree, pFour, pFive))>::value, Ptr<typename std::remove_reference<decltype(arg(pOne, pTwo, pThree, pFour, pFive))>::type>>>

// TODO add proper description

Template Parameters
ParamOne// TODO add proper description
ParamTwo// TODO add proper description
ParamThree// TODO add proper description
ParamFour// TODO add proper description
ParamFive// TODO add proper description
F// TODO add proper description
Parameters
pOne// TODO add proper description
pTwo// TODO add proper description
pThree// TODO add proper description
pFour// TODO add proper description
pFive// TODO add proper description
arg// TODO add proper description
Returns
// TODO add proper description

Definition at line 230 of file CPPLambdaCreationFunctions.h.

template<typename ClassType >
LambdaTree<Ptr<ClassType> > pdb::makeLambdaFromSelf ( Handle< ClassType > &  var)

creates a PDB lambda that simply returns the argument itself

Template Parameters
ClassType// TODO add proper description
Parameters
var// TODO add proper description
Returns
// TODO add proper description

Definition at line 35 of file SelfLambdaCreationFunctions.h.

template<typename ReturnType , typename ClassType >
LambdaTree<Ptr<ReturnType> > pdb::makeLambdaUsingMember ( std::string  inputTypeName,
std::string  attName,
std::string  attType,
Handle< ClassType > &  var,
ReturnType *  member,
size_t  offset 
)

creates a PDB lambda that returns a member of a C++ class

Template Parameters
ReturnType// TODO add proper description
ClassType// TODO add proper description
Parameters
inputTypeName// TODO add proper description
attName// TODO add proper description
attType// TODO add proper description
var// TODO add proper description
member// TODO add proper description
offset// TODO add proper description
Returns
// TODO add proper description

Definition at line 42 of file AttAccessLambdaCreationFunctions.h.

template<typename ReturnType , typename ClassType >
LambdaTree<std::enable_if_t<std::is_reference<ReturnType>::value, Ptr<typename std::remove_reference<ReturnType>::type> > > pdb::makeLambdaUsingMethod ( std::string  inputTypeName,
std::string  methodName,
Handle< ClassType > &  var,
std::string  returnTypeName,
ReturnType(ClassType::*)()  arg,
std::function< bool(std::string &, TupleSetPtr, int)>  columnBuilder,
std::function< SimpleComputeExecutorPtr(TupleSpec &, TupleSpec &, TupleSpec &)>  getExecutor 
)

this bit of nasty templating defines a function that creates a LambdaBase object encapsulating a method call on an underlying object. This particular template accepts only methods that return references, because such a method's output is converted into a pointer (for speed) rather than actually copying the method's output

Template Parameters
ReturnType// TODO add proper description
ClassType// TODO add proper description
Parameters
inputTypeName// TODO add proper description
methodName// TODO add proper description
var// TODO add proper description
returnTypeName// TODO add proper description
arg// TODO add proper description
columnBuilder// TODO add proper description
getExecutor// TODO add proper description
Returns
// TODO add proper description

Definition at line 44 of file MethodCallLambdaCreationFunctions.h.

template<typename ReturnType , typename ClassType >
LambdaTree<std::enable_if_t<!(std::is_reference<ReturnType>::value), ReturnType> > pdb::makeLambdaUsingMethod ( std::string  inputTypeName,
std::string  methodName,
Handle< ClassType > &  var,
std::string  returnTypeName,
ReturnType(ClassType::*)()  arg,
std::function< bool(std::string &, TupleSetPtr, int)>  columnBuilder,
std::function< SimpleComputeExecutorPtr(TupleSpec &, TupleSpec &, TupleSpec &)>  getExecutor 
)

// TODO add proper description

Template Parameters
ReturnType// TODO add proper description
ClassType// TODO add proper description
Parameters
inputTypeName// TODO add proper description
methodName// TODO add proper description
var// TODO add proper description
returnTypeName// TODO add proper description
arg// TODO add proper description
columnBuilder// TODO add proper description
getExecutor// TODO add proper description
Returns
// TODO add proper description

Definition at line 74 of file MethodCallLambdaCreationFunctions.h.

template<class ObjType , class... Args>
RefCountedObject< ObjType > * pdb::makeObject ( Args &&...  args)

Definition at line 157 of file InterfaceFunctions.cc.

+ Here is the call graph for this function:

void pdb::makeObjectAllocatorBlock ( size_t  numBytesIn,
bool  throwExceptionOnFail 
)
inline

Definition at line 65 of file InterfaceFunctions.cc.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void pdb::makeObjectAllocatorBlock ( void *  spaceToUse,
size_t  numBytesIn,
bool  throwExceptionOnFail 
)
inline

Definition at line 81 of file InterfaceFunctions.cc.

+ Here is the call graph for this function:

template<class ObjType , class... Args>
RefCountedObject< ObjType > * pdb::makeObjectWithExtraStorage ( size_t  extra,
Args &&...  args 
)

Definition at line 202 of file InterfaceFunctions.cc.

+ Here is the call graph for this function:

unsigned int pdb::newHash ( unsigned int  x)
inline

Definition at line 28 of file PDBMap.cc.

+ Here is the caller graph for this function:

template<typename LeftType , typename RightType >
LambdaTree<bool> pdb::operator&& ( LambdaTree< LeftType >  lhs,
LambdaTree< RightType >  rhs 
)

creates a PDB lambda from an && operator

Template Parameters
LeftType// TODO add proper description
RightType// TODO add proper description
Parameters
lhs// TODO add proper description
rhs// TODO add proper description
Returns
// TODO add proper description

Definition at line 36 of file AndLambdaCreationFunctions.h.

Handle<Map<String, Vector<int> > >& pdb::operator+ ( Handle< Map< String, Vector< int >>> &  lhs,
Handle< Map< String, Vector< int >>> &  rhs 
)
inline

Definition at line 70 of file DepartmentEmployeeAges.h.

Map<String, Vector<OptimizedEmployee> >& pdb::operator+ ( Map< String, Vector< OptimizedEmployee >> &  lhs,
Map< String, Vector< OptimizedEmployee >> &  rhs 
)
inline

Definition at line 71 of file OptimizedDepartmentEmployees.h.

+ Here is the call graph for this function:

Map<String, Vector<Handle<Employee> > >& pdb::operator+ ( Map< String, Vector< Handle< Employee >>> &  lhs,
Map< String, Vector< Handle< Employee >>> &  rhs 
)
inline

Definition at line 71 of file DepartmentEmployees.h.

bool pdb::operator< ( const InactiveAllocationBlock &  in,
const void *  compToMe 
)
inline

Definition at line 54 of file Allocator.cc.

bool pdb::operator< ( const InactiveAllocationBlock &  lhs,
const InactiveAllocationBlock &  rhs 
)
inline

Definition at line 59 of file Allocator.cc.

std::ostream& pdb::operator<< ( std::ostream &  stream,
const String &  printMe 
)
inline

Definition at line 201 of file PDBString.cc.

+ Here is the call graph for this function:

template<typename LeftType , typename RightType >
LambdaTree<bool> pdb::operator== ( LambdaTree< LeftType >  lhs,
LambdaTree< RightType >  rhs 
)

creates a PDB lambda out of an == operator

Template Parameters
LeftType// TODO add proper description
RightType// TODO add proper description
Parameters
lhs// TODO add proper description
rhs// TODO add proper description
Returns
// TODO add proper description

Definition at line 36 of file EqualsLambdaCreationFunctions.h.

bool pdb::operator== ( const InactiveAllocationBlock &  in,
const void *  compToMe 
)
inline

Definition at line 69 of file Allocator.cc.

bool pdb::operator> ( const InactiveAllocationBlock &  in,
const void *  compToMe 
)
inline

Definition at line 64 of file Allocator.cc.

template<typename TypeToPack >
std::enable_if<sizeof(TypeToPack::myOtherData) == 0, void>::type pdb::pack ( TypeToPack &  arg,
int  whichPosInTupleSet,
int  whichVec,
void **  us 
)

Definition at line 191 of file JoinTuple.h.

+ Here is the caller graph for this function:

template<typename TypeToPack >
std::enable_if<sizeof(TypeToPack::myOtherData) != 0, void>::type pdb::pack ( TypeToPack &  arg,
int  whichPosInTupleSet,
int  whichVec,
void **  us 
)

Definition at line 204 of file JoinTuple.h.

+ Here is the call graph for this function:

template<typename TypeToPackData >
std::enable_if<(sizeof(TypeToPackData::myOtherData) == 0) && (sizeof(TypeToPackData::myData) != 0), void>::type pdb::packData ( TypeToPackData &  arg,
TypeToPackData  data 
)

Definition at line 169 of file JoinTuple.h.

+ Here is the caller graph for this function:

template<typename TypeToPackData >
std::enable_if<(sizeof(TypeToPackData::myOtherData) != 0) && (sizeof(TypeToPackData::myData) != 0), void>::type pdb::packData ( TypeToPackData &  arg,
TypeToPackData  data 
)

Definition at line 179 of file JoinTuple.h.

+ Here is the call graph for this function:

bool pdb::recurse ( LogicalPlanPtr  myPlan,
std::vector< AtomicComputationPtr > &  listSoFar,
std::string &  targetTupleSetName 
)
inline

Definition at line 80 of file ComputePlan.cc.

+ Here is the caller graph for this function:

template<class RequestType , class SecondRequestType , class ResponseType , class ReturnType >
ReturnType pdb::simpleDoubleRequest ( PDBLoggerPtr  myLogger,
int  port,
std::string  address,
ReturnType  onErr,
size_t  bytesForRequest,
function< ReturnType(Handle< ResponseType >)>  processResponse,
Handle< RequestType > &  firstRequest,
Handle< SecondRequestType > &  secondRequest 
)

Definition at line 130 of file SimpleRequest.cc.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

template<class RequestType , class ResponseType , class ReturnType , class... RequestTypeParams>
ReturnType pdb::simpleRequest ( PDBLoggerPtr  myLogger,
int  port,
std::string  address,
ReturnType  onErr,
size_t  bytesForRequest,
function< ReturnType(Handle< ResponseType >)>  processResponse,
RequestTypeParams &&...  args 
)

JiaNote: we need free memory here !!!

Definition at line 39 of file SimpleRequest.cc.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

template<class RequestType , class ResponseType , class ReturnType , class... RequestTypeParams>
ReturnType pdb::simpleSendBytesRequest ( PDBLoggerPtr  myLogger,
int  port,
std::string  address,
ReturnType  onErr,
size_t  bytesForRequest,
function< ReturnType(Handle< ResponseType >)>  processResponse,
char *  bytes,
size_t  numBytes,
RequestTypeParams &&...  args 
)

Definition at line 35 of file SimpleSendBytesRequest.cc.

+ Here is the call graph for this function:

template<class RequestType , class DataType , class ResponseType , class ReturnType , class... RequestTypeParams>
ReturnType pdb::simpleSendDataRequest ( PDBLoggerPtr  myLogger,
int  port,
std::string  address,
ReturnType  onErr,
size_t  bytesForRequest,
function< ReturnType(Handle< ResponseType >)>  processResponse,
Handle< Vector< DataType >>  dataToSend,
RequestTypeParams &&...  args 
)

Definition at line 39 of file SimpleSendDataRequest.cc.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

template<class RequestType , class DataType , class ResponseType , class ReturnType , class... RequestTypeParams>
ReturnType pdb::simpleSendObjectRequest ( PDBLoggerPtr  myLogger,
int  port,
std::string  address,
ReturnType  onErr,
size_t  bytesForRequest,
function< ReturnType(Handle< ResponseType >)>  processResponse,
DataType  dataToSend,
RequestTypeParams &&...  args 
)

Definition at line 39 of file SimpleSendObjectRequest.cc.

+ Here is the call graph for this function:

size_t pdb::specialHash ( unsigned  u)
inline

Definition at line 59 of file PairArray.cc.

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

size_t pdb::specialHash ( int  u)
inline

Definition at line 63 of file PairArray.cc.

+ Here is the call graph for this function:

template<typename TypeToTruncate >
std::enable_if<sizeof(TypeToTruncate::myOtherData) == 0, void>::type pdb::truncate ( int  i,
int  whichVec,
void **  us 
)

Definition at line 254 of file JoinTuple.h.

+ Here is the call graph for this function:

template<typename TypeToTruncate >
std::enable_if<sizeof(TypeToTruncate::myOtherData) != 0, void>::type pdb::truncate ( int  i,
int  whichVec,
void **  us 
)

Definition at line 264 of file JoinTuple.h.

+ Here is the caller graph for this function:

template<bool B, typename InputType >
auto pdb::tryDereference ( InputType &  arg) -> typename std::enable_if_t<B, decltype(*arg) &>

Definition at line 30 of file TupleSet.h.

template<bool B, typename InputType >
auto pdb::tryDereference ( InputType &&  arg) -> typename std::enable_if_t<!B, InputType&>

Definition at line 36 of file TupleSet.h.

template<bool B, typename InputType >
auto pdb::tryReference ( InputType &  arg) -> typename std::enable_if_t<B, InputType*>

called if ReturnType is a reference

Template Parameters
B// TODO add proper description
InputType// TODO add proper description
Parameters
arg// TODO add proper description
Returns
// TODO add proper description

Definition at line 100 of file MethodCallLambdaCreationFunctions.h.

template<bool B, typename InputType >
auto pdb::tryReference ( InputType  arg) -> typename std::enable_if_t<!B, InputType*>

called if ReturnType is a reference

Template Parameters
B// TODO add proper description
InputType// TODO add proper description
Parameters
arg// TODO add proper description
Returns
// TODO add proper description

Definition at line 112 of file MethodCallLambdaCreationFunctions.h.

template<bool B, typename InputType >
auto pdb::tryToObtainPointer ( InputType &  arg) -> typename std::enable_if_t<B, InputType*>

Definition at line 54 of file TupleSet.h.

template<typename TypeToUnPack >
std::enable_if<sizeof(TypeToUnPack::myOtherData) == 0, void>::type pdb::unpack ( TypeToUnPack &  arg,
int  whichPosInTupleSet,
int  whichVec,
void **  us 
)

Definition at line 215 of file JoinTuple.h.

+ Here is the caller graph for this function:

template<typename TypeToUnPack >
std::enable_if<sizeof(TypeToUnPack::myOtherData) != 0, void>::type pdb::unpack ( TypeToUnPack &  arg,
int  whichPosInTupleSet,
int  whichVec,
void **  us 
)

Definition at line 222 of file JoinTuple.h.

+ Here is the call graph for this function:

template<class OutObjType , class InObjType >
Handle< OutObjType > pdb::unsafeCast ( Handle< InObjType > &  castMe)

Definition at line 265 of file InterfaceFunctions.cc.

Variable Documentation

GenericHandle pdb::foofoo
bool pdb::inSharedLibrary

Definition at line 31 of file GlobalVariables.cc.

Allocator* pdb::mainAllocatorPtr

Definition at line 37 of file GlobalVariables.cc.

NotEnoughSpace pdb::myException

Definition at line 52 of file GlobalVariables.cc.

void * pdb::someRandomPointer

we have this here only so that we can cast it to be of type VAR

Definition at line 24 of file LambdaCreationFunctions.cc.

void * pdb::stackBase

Definition at line 31 of file PDBWorkerQueue.cc.

void * pdb::stackEnd

Definition at line 32 of file PDBWorkerQueue.cc.

VTableMap* pdb::theVTable

Definition at line 49 of file GlobalVariables.cc.