Struct SqlFile 

pub struct SqlFile<F: AsyncWrite + Unpin + Send + Sync> { /* private fields */ }

A file to output sql to

Implementations

impl SqlFile<BufWriter<File>>

pub async fn new_file( path: &str, identifier_quoter: Arc<IdentifierQuoter>, options: SqlFileOptions, ) -> Result<Self>

Create a new SqlFile from a file path. This automatically creates a new file and returns a SqlFile that writes to it.

impl<F: AsyncWrite + Unpin + Send + Sync> SqlFile<F>

pub async fn new( file: F, identifier_quoter: Arc<IdentifierQuoter>, options: SqlFileOptions, ) -> Result<Self>

Create a new SqlFile from a file-like object. This does not do any additional buffering so it’s recommended to use a BufWriter or similar.

Trait Implementations

impl<F: AsyncWrite + Unpin + Send + Sync> BaseCopyTarget for SqlFile<F>

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

Which data format is supported by this destination/source.

impl<F: AsyncWrite + Unpin + Send + Sync> CopyDestination for &mut SqlFile<F>

type Transaction<'a> = &'a mut SqlFile<F> where Self: 'a

The transaction type returned by begin_transaction.

async fn apply_data<R: TableDataReader, C: AsyncCleanup>( &mut self, schema: &PostgresSchema, table: &PostgresTable, data: TableData<R, C>, ) -> Result<()>

This should apply the data to the destination. The data is expected to be in the format returned by supported_data_format, if possible.

async fn apply_non_transactional_statement( &mut self, statement: &str, ) -> Result<()>

This should apply the DDL statements to the destination. These commands has to be run outside a transaction, as they might fail otherwise.

async fn begin_transaction(&mut self) -> Result<&mut SqlFile<F>>

Should begin a new transaction and return a handle to it.

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

Should get the identifier quoter that works with this destination. This ensures quoting respects the rules of the destination, not the source.

async fn finish(&mut self) -> Result<()>

fn try_introspect( &self, ) -> impl Future<Output = Result<Option<PostgresDatabase>>>

Should try to introspect the destination. If introspection is not supported, this should return Ok(None), not an error. Errors should only be returned if introspection is supported, but failed.

fn has_data_in_table( &self, _schema: &PostgresSchema, _table: &PostgresTable, ) -> impl Future<Output = Result<bool>>

impl<'a, F: AsyncWrite + Unpin + Send + Sync + 'a> CopyDestinationFactory<'a> for SqlFile<F>

type SequentialDestination = &'a mut SqlFile<F>

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

type ParallelDestination = ParallelCopyDestinationNotAvailable

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<F: AsyncWrite + Unpin + Send + Sync> CopyTransaction for &mut SqlFile<F>

async fn apply_statement(&mut self, statement: &str) -> Result<()>

Apply a DDL statement within this transaction.

async fn commit(self) -> Result<()>

Commit the transaction.