Use separate array for raw tables

Author: simolus3

crates/core/src/schema/mod.rs

@@ -6,13 +6,14 @@ use serde::Deserialize;
 use sqlite::ResultCode;
 use sqlite_nostd as sqlite;
 pub use table_info::{
-    DiffIncludeOld, PendingStatement, PendingStatementValue, RawTableDefinition, Table,
-    TableInfoFlags,
+    DiffIncludeOld, PendingStatement, PendingStatementValue, RawTable, Table, TableInfoFlags,
 };
 
 #[derive(Deserialize, Default)]
 pub struct Schema {
     pub tables: Vec<table_info::Table>,
+    #[serde(default)]
+    pub raw_tables: Vec<table_info::RawTable>,
 }
 
 pub fn register(db: *mut sqlite::sqlite3) -> Result<(), ResultCode> {

crates/core/src/schema/table_info.rs

@@ -17,8 +17,13 @@ pub struct Table {
     pub diff_include_old: Option<DiffIncludeOld>,
     #[serde(flatten)]
     pub flags: TableInfoFlags,
-    #[serde(default)]
-    pub raw: Option<RawTableDefinition>,
+}
+
+#[derive(Deserialize)]
+pub struct RawTable {
+    pub name: String,
+    pub put: PendingStatement,
+    pub delete: PendingStatement,
 }
 
 impl Table {
@@ -228,12 +233,6 @@ impl<'de> Deserialize<'de> for TableInfoFlags {
     }
 }
 
-#[derive(Deserialize)]
-pub struct RawTableDefinition {
-    pub put: PendingStatement,
-    pub delete: PendingStatement,
-}
-
 #[derive(Deserialize)]
 pub struct PendingStatement {
     pub sql: String,

crates/core/src/sync_local.rs

@@ -5,7 +5,7 @@ use alloc::vec::Vec;
 use serde::Deserialize;
 
 use crate::error::{PSResult, SQLiteError};
-use crate::schema::{PendingStatement, PendingStatementValue, RawTableDefinition, Schema};
+use crate::schema::{PendingStatement, PendingStatementValue, RawTable, Schema};
 use crate::sync::BucketPriority;
 use sqlite_nostd::{self as sqlite, Destructor, ManagedStmt, Value};
 use sqlite_nostd::{ColumnType, Connection, ResultCode};
@@ -392,11 +392,9 @@ impl<'a> ParsedDatabaseSchema<'a> {
     }
 
     fn add_from_schema(&mut self, schema: &'a Schema) {
-        for table in &schema.tables {
-            if let Some(raw) = &table.raw {
-                self.tables
-                    .insert(table.name.clone(), ParsedSchemaTable::raw(raw));
-            }
+        for raw in &schema.raw_tables {
+            self.tables
+                .insert(raw.name.clone(), ParsedSchemaTable::raw(raw));
         }
     }
 
@@ -426,7 +424,7 @@ struct ParsedSchemaTable<'a> {
 }
 
 struct RawTableWithCachedStatements<'a> {
-    definition: &'a RawTableDefinition,
+    definition: &'a RawTable,
     cached_put: Option<PreparedPendingStatement<'a>>,
     cached_delete: Option<PreparedPendingStatement<'a>>,
 }
@@ -464,7 +462,7 @@ impl<'a> ParsedSchemaTable<'a> {
         Self { raw: None }
     }
 
-    pub fn raw(definition: &'a RawTableDefinition) -> Self {
+    pub fn raw(definition: &'a RawTable) -> Self {
         Self {
             raw: Some(RawTableWithCachedStatements {
                 definition,

dart/test/schema_test.dart

@@ -120,6 +120,36 @@ void main() {
         );
       });
     });
+
+    test('raw tables', () {
+      db.execute('SELECT powersync_replace_schema(?)', [
+        json.encode({
+          'raw_tables': [
+            {
+              'name': 'users',
+              'put': {
+                'sql': 'INSERT OR REPLACE INTO users (id, name) VALUES (?, ?);',
+                'params': [
+                  'Id',
+                  {'Column': 'name'}
+                ],
+              },
+              'delete': {
+                'sql': 'DELETE FROM users WHERE id = ?',
+                'params': ['Id'],
+              },
+            }
+          ],
+          'tables': [],
+        })
+      ]);
+
+      expect(
+        db.select(
+            "SELECT * FROM sqlite_schema WHERE type = 'table' AND name LIKE 'ps_data%'"),
+        isEmpty,
+      );
+    });
   });
 }
 

dart/test/sync_test.dart

@@ -681,26 +681,24 @@ void _syncTests<T>({
         'start',
         json.encode({
           'schema': {
-            'tables': [
+            'raw_tables': [
               {
                 'name': 'users',
-                'raw': {
-                  'put': {
-                    'sql':
-                        'INSERT OR REPLACE INTO users (id, name) VALUES (?, ?);',
-                    'params': [
-                      'Id',
-                      {'Column': 'name'}
-                    ],
-                  },
-                  'delete': {
-                    'sql': 'DELETE FROM users WHERE id = ?',
-                    'params': ['Id'],
-                  },
+                'put': {
+                  'sql':
+                      'INSERT OR REPLACE INTO users (id, name) VALUES (?, ?);',
+                  'params': [
+                    'Id',
+                    {'Column': 'name'}
+                  ],
+                },
+                'delete': {
+                  'sql': 'DELETE FROM users WHERE id = ?',
+                  'params': ['Id'],
                 },
-                'columns': [],
               }
             ],
+            'tables': [],
           },
         }),
       );