Struct CreateExtension 

pub struct CreateExtension {
    pub name: String,
    pub schema: Option<String>,
    pub version: Option<String>,
}

Available on native and crate feature database only.

Create a PostgreSQL extension

PostgreSQL extensions add additional functionality to the database. Common extensions include hstore, postgis, pg_trgm, and many others.

Example

use reinhardt_db::migrations::operations::postgres::CreateExtension;
use reinhardt_db::migrations::ProjectState;

let mut state = ProjectState::new();
let ext = CreateExtension::new("hstore");

// Extensions don't modify project state
ext.state_forwards("myapp", &mut state);

Fields

name: String

The name.

schema: Option<String>

The schema.

version: Option<String>

The version.

Implementations

impl CreateExtension

pub fn new(name: impl Into<String>) -> CreateExtension

Create a new CreateExtension operation

Example

use reinhardt_db::migrations::operations::postgres::CreateExtension;

let ext = CreateExtension::new("hstore");
assert_eq!(ext.name, "hstore");
assert!(ext.schema.is_none());

pub fn with_schema(self, schema: impl Into<String>) -> CreateExtension

Set the schema where the extension should be created

pub fn with_version(self, version: impl Into<String>) -> CreateExtension

Set a specific version of the extension

pub fn state_forwards(&self, _app_label: &str, _state: &mut ProjectState)

Apply to project state (extensions don’t modify state)

pub fn database_forwards( &self, _schema_editor: &dyn BaseDatabaseSchemaEditor, ) -> Vec<String>

Generate SQL using schema editor

Example

use reinhardt_db::migrations::operations::postgres::CreateExtension;
use reinhardt_db::backends::schema::factory::{SchemaEditorFactory, DatabaseType};

let ext = CreateExtension::new("hstore").with_schema("public");
let factory = SchemaEditorFactory::new();
let editor = factory.create_for_database(DatabaseType::PostgreSQL);

let sql = ext.database_forwards(editor.as_ref());
assert_eq!(sql.len(), 1);
assert!(sql[0].contains("CREATE EXTENSION"));
assert!(sql[0].contains("hstore"));

pub fn database_backwards( &self, _schema_editor: &dyn BaseDatabaseSchemaEditor, ) -> Vec<String>

Generate reverse SQL

Example

use reinhardt_db::migrations::operations::postgres::CreateExtension;
use reinhardt_db::backends::schema::factory::{SchemaEditorFactory, DatabaseType};

let ext = CreateExtension::new("hstore");
let factory = SchemaEditorFactory::new();
let editor = factory.create_for_database(DatabaseType::PostgreSQL);

let sql = ext.database_backwards(editor.as_ref());
assert_eq!(sql.len(), 1);
assert!(sql[0].contains("DROP EXTENSION"));

Trait Implementations

impl Clone for CreateExtension

fn clone(&self) -> CreateExtension

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CreateExtension

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CreateExtension

fn deserialize<__D>( __deserializer: __D, ) -> Result<CreateExtension, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl MigrationOperation for CreateExtension

fn migration_name_fragment(&self) -> Option<String>

Generate a fragment for the migration name

fn describe(&self) -> String

Human-readable description of this operation

fn normalize(&self) -> Self

where Self: Sized + Clone,

Normalize operation for comparison

fn semantically_equal(&self, other: &Self) -> bool

where Self: Sized + Clone + PartialEq,

Check if two operations are semantically equal

impl Serialize for CreateExtension

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.