Struct PostgresInstanceStorage 

pub struct PostgresInstanceStorage<'a> { /* private fields */ }

A CopyTarget for Postgres.

Implementations

impl<'a> PostgresInstanceStorage<'a>

pub async fn new(connection: &'a PostgresClientWrapper) -> Result<Self>

pub fn get_identifier_quoter(&self) -> Arc<IdentifierQuoter>

Trait Implementations

impl BaseCopyTarget for PostgresInstanceStorage<'_>

async fn supported_data_format(&self) -> Result<Vec<DataFormat>>

Which data format is supported by this destination/source.

impl<'a> CopyDestinationFactory<'a> for PostgresInstanceStorage<'a>

type SequentialDestination = SequentialSafePostgresInstanceCopyDestinationStorage<'a>

The implementation type when dealing with single-threaded workloads. The can optionally support multi-threading, but it is not needed.

type ParallelDestination = ParallelSafePostgresInstanceCopyDestinationStorage<'a>

The implementation type when dealing with multithreaded workloads. This type has to support multi-threading.

async fn create_destination( &'a mut self, ) -> Result<SequentialOrParallel<Self::SequentialDestination, Self::ParallelDestination>>

Should create whatever type is needed to be able to write data to the destination.

async fn create_sequential_destination( &'a mut self, ) -> Result<Self::SequentialDestination>

Should create a destination that works with single threaded writing.

fn supported_parallelism(&self) -> SupportedParallelism

Should return what kind of parallelism is supported by the destination. This is used for negotiation with the source.

impl<'a> CopySourceFactory for PostgresInstanceStorage<'a>

type SequentialSource = SequentialSafePostgresInstanceCopySourceStorage<'a>

A type that can be used to read data from the source. This type has to support single threaded reading, but can support multiple threads reading at the same time.

type ParallelSource = ParallelSafePostgresInstanceCopySourceStorage<'a>

A type that can be used to read data from the source. This type has to support multiple threads reading at the same time.

async fn create_source( &self, ) -> Result<SequentialOrParallel<Self::SequentialSource, Self::ParallelSource>>

Should create whatever type is needed to be able to read data from the source.

async fn create_sequential_source(&self) -> Result<Self::SequentialSource>

Should create a datasource that works with single threaded reading.

fn supported_parallelism(&self) -> SupportedParallelism

Should return what kind of parallelism is supported by the source. This is used for negotiation with the destination.