@@ -6173,11 +6173,13 @@ pub enum Statement {
         limit: Option<Expr>,
     },
     /// ```sql
-    /// CREATE [ OR REPLACE ] TABLE [ IF NOT EXISTS ] <name>
+    /// CREATE [ OR REPLACE ] { TABLE | SCHEMA | DATABASE } [ IF NOT EXISTS ] <name>
     ///   FROM BACKUP SET <backup_set> IDENTIFIER '<backup_id>'
     /// ```
     /// See <https://docs.snowflake.com/en/sql-reference/sql/create-table>
-    CreateTableFromBackupSet {
+    CreateFromBackupSet {
+        /// The kind of object restored (`TABLE`, `SCHEMA` or `DATABASE`).
+        kind: BackupSetTargetKind,
         /// `OR REPLACE` flag (always rejected by Snowflake).
         or_replace: bool,
         /// `IF NOT EXISTS` flag.
@@ -9994,15 +9996,16 @@ impl fmt::Display for Statement {
                 }
                 Ok(())
             }
-            Statement::CreateTableFromBackupSet {
+            Statement::CreateFromBackupSet {
+                kind,
                 or_replace,
                 if_not_exists,
                 name,
                 backup_set,
                 backup_id,
             } => write!(
                 f,
-                "CREATE {or_replace}TABLE {if_not_exists}{name} FROM BACKUP SET {backup_set} IDENTIFIER '{backup_id}'",
+                "CREATE {or_replace}{kind} {if_not_exists}{name} FROM BACKUP SET {backup_set} IDENTIFIER '{backup_id}'",
                 or_replace = if *or_replace { "OR REPLACE " } else { "" },
                 if_not_exists = if *if_not_exists { "IF NOT EXISTS " } else { "" },
                 backup_id = value::escape_single_quote_string(backup_id),
 
@@ -633,7 +633,7 @@ impl Spanned for Statement {
             Statement::DescribeBackupSet { .. } => Span::empty(),
             Statement::ShowBackupSets { .. } => Span::empty(),
             Statement::ShowBackups { .. } => Span::empty(),
-            Statement::CreateTableFromBackupSet { .. } => Span::empty(),
+            Statement::CreateFromBackupSet { .. } => Span::empty(),
             Statement::CreateNetworkRule { .. } => Span::empty(),
             Statement::AlterNetworkRule { .. } => Span::empty(),
             Statement::DropNetworkRule { .. } => Span::empty(),
 
@@ -868,6 +868,17 @@ impl SnowflakeDialect {
                 return Some(parse_create_tag(or_replace, parser));
             }
 
+            let plain_create = !(or_replace || or_alter || global.is_some() || temporary || volatile
+                || transient || iceberg || dynamic || hybrid);
+            if plain_create && parser.parse_keyword(Keyword::SCHEMA) {
+                if let Some(restore) =
+                    parse_create_from_backup_set(BackupSetTargetKind::Schema, false, parser)
+                {
+                    return Some(restore);
+                }
+                parser.prev_token();
+            }
+
             if parser.parse_keyword(Keyword::STAGE) {
                 // OK - this is CREATE STAGE statement
                 return Some(parse_create_stage(or_replace, or_alter, temporary, parser));
@@ -891,7 +902,9 @@ impl SnowflakeDialect {
                 ).map(Into::into));
             } else if parser.parse_keyword(Keyword::TABLE) {
                 if !(or_alter || global.is_some() || temporary || volatile || transient || iceberg || dynamic || hybrid) {
-                    if let Some(restore) = parse_create_table_from_backup_set(or_replace, parser) {
+                    if let Some(restore) =
+                        parse_create_from_backup_set(BackupSetTargetKind::Table, or_replace, parser)
+                    {
                         return Some(restore);
                     }
                 }
@@ -906,6 +919,13 @@ impl SnowflakeDialect {
                 if parser.parse_keyword(Keyword::ROLE) {
                     return Some(parser.parse_create_database_role(or_replace));
                 }
+                if plain_create {
+                    if let Some(restore) =
+                        parse_create_from_backup_set(BackupSetTargetKind::Database, false, parser)
+                    {
+                        return Some(restore);
+                    }
+                }
                 return Some(parse_create_database(or_replace, transient, parser));
             } else if parser.parse_keywords(&[Keyword::APPLICATION, Keyword::ROLE]) {
                 return Some(parser.parse_create_application_role(or_replace, or_alter));
@@ -6351,9 +6371,11 @@ fn parse_show_backups(parser: &mut Parser) -> Result<Statement, ParserError> {
 }
 
 /// Parse `[ IF NOT EXISTS ] <name> FROM BACKUP SET <set> IDENTIFIER '<id>'`
-/// after `CREATE [ OR REPLACE ] TABLE`. Returns `None` (tokens rewound) when
-/// the statement is not a restore, so the ordinary CREATE TABLE parser runs.
-fn parse_create_table_from_backup_set(
+/// after `CREATE [ OR REPLACE ] { TABLE | SCHEMA | DATABASE }`. Returns `None`
+/// (tokens rewound) when the statement is not a restore, so the ordinary
+/// CREATE parser runs.
+fn parse_create_from_backup_set(
+    kind: BackupSetTargetKind,
     or_replace: bool,
     parser: &mut Parser,
 ) -> Option<Result<Statement, ParserError>> {
@@ -6369,7 +6391,8 @@ fn parse_create_table_from_backup_set(
     let tail = parser.parse_object_name(false).and_then(|backup_set| {
         Ok((backup_set, parse_backup_identifier(parser)?))
     });
-    Some(tail.map(|(backup_set, backup_id)| Statement::CreateTableFromBackupSet {
+    Some(tail.map(|(backup_set, backup_id)| Statement::CreateFromBackupSet {
+        kind,
         or_replace,
         if_not_exists,
         name,