|
| 1 | +/* eslint-env node */ |
| 2 | +import { readFileSync, readdirSync, writeFileSync } from 'fs-extra'; |
| 3 | +import { resolve, join } from 'path'; |
| 4 | +import { |
| 5 | + parse, |
| 6 | + type CreateTableStmt, |
| 7 | + type AlterTableStmt, |
| 8 | + type Program, |
| 9 | +} from 'sql-parser-cst'; |
| 10 | + |
| 11 | +// Currently this script only cares about CREATE TABLE statements and ALTER |
| 12 | +// TABLE statements that add primary key constraints. All the other schema aspects of the |
| 13 | +// pg_dump are generally beyond the capability of SQLite. Perhaps index creation |
| 14 | +// can be added but it will get really tricky fast since SQLite's indices are |
| 15 | +// more more simplistic than postgres. |
| 16 | + |
| 17 | +const args = process.argv; |
| 18 | +const migrationsDir = resolve(join(__dirname, '..', 'migrations')); |
| 19 | +const sqliteSchemaDir = resolve( |
| 20 | + join(__dirname, '..', '..', 'host', 'config', 'schema'), |
| 21 | +); |
| 22 | +const INDENT = ' '; |
| 23 | + |
| 24 | +let pgDumpFile = args[2]; |
| 25 | +if (!pgDumpFile) { |
| 26 | + console.error(`please specify the path of the pg_dump file`); |
| 27 | + process.exit(-1); |
| 28 | +} |
| 29 | +let pgDump = readFileSync(pgDumpFile, 'utf8'); |
| 30 | + |
| 31 | +let cst = parse(prepareDump(pgDump), { |
| 32 | + dialect: 'postgresql', |
| 33 | + includeSpaces: true, |
| 34 | + includeNewlines: true, |
| 35 | + includeComments: true, |
| 36 | + includeRange: true, |
| 37 | +}); |
| 38 | + |
| 39 | +let sql: string[] = [ |
| 40 | + ` |
| 41 | +-- This is auto-generated from packages/realm-server/scripts/convert-to-sqlite.ts |
| 42 | +-- Please don't directly modify this file |
| 43 | +
|
| 44 | +`, |
| 45 | +]; |
| 46 | +for (let statement of cst.statements) { |
| 47 | + if (statement.type !== 'create_table_stmt') { |
| 48 | + continue; |
| 49 | + } |
| 50 | + sql.push('CREATE TABLE IF NOT EXISTS'); |
| 51 | + if ( |
| 52 | + statement.name.type === 'member_expr' && |
| 53 | + statement.name.property.type === 'identifier' |
| 54 | + ) { |
| 55 | + let tableName = statement.name.property.name; |
| 56 | + sql.push(statement.name.property.name, '(\n'); |
| 57 | + createColumns(cst, tableName, statement, sql); |
| 58 | + } else { |
| 59 | + throw new Error(`could not determine table name to be created`); |
| 60 | + } |
| 61 | + |
| 62 | + sql.push('\n);\n\n'); |
| 63 | +} |
| 64 | + |
| 65 | +let result = sql.join(' ').trim(); |
| 66 | +let filename = getSchemaFilename(); |
| 67 | +let schemaFile = join(sqliteSchemaDir, filename); |
| 68 | +writeFileSync(schemaFile, result); |
| 69 | +console.log(`created SQLite schema file ${schemaFile}`); |
| 70 | + |
| 71 | +function createColumns( |
| 72 | + cst: Program, |
| 73 | + tableName: string, |
| 74 | + statement: CreateTableStmt, |
| 75 | + sql: string[], |
| 76 | +) { |
| 77 | + if (!statement.columns) { |
| 78 | + return; |
| 79 | + } |
| 80 | + let columns: string[] = []; |
| 81 | + for (let item of statement.columns.expr.items) { |
| 82 | + if (item.type !== 'column_definition') { |
| 83 | + continue; |
| 84 | + } |
| 85 | + let column: string[] = []; |
| 86 | + column.push(INDENT, item.name.name); |
| 87 | + if (item.dataType?.type === 'named_data_type') { |
| 88 | + let dataTypeName = Array.isArray(item.dataType.nameKw) |
| 89 | + ? item.dataType.nameKw[0] |
| 90 | + : item.dataType.nameKw; |
| 91 | + switch (dataTypeName.name) { |
| 92 | + case 'CHARACTER': |
| 93 | + column.push('TEXT'); |
| 94 | + break; |
| 95 | + case 'JSONB': |
| 96 | + // TODO change this to 'BLOB' after we do the sqlite BLOB storage |
| 97 | + // support in CS-6668 for faster performance |
| 98 | + column.push('JSON'); |
| 99 | + break; |
| 100 | + case 'BOOLEAN': |
| 101 | + column.push('BOOLEAN'); |
| 102 | + break; |
| 103 | + case 'INTEGER': |
| 104 | + column.push('INTEGER'); |
| 105 | + break; |
| 106 | + } |
| 107 | + } |
| 108 | + for (let constraint of item.constraints) { |
| 109 | + switch (constraint.type) { |
| 110 | + case 'constraint_not_null': |
| 111 | + column.push('NOT NULL'); |
| 112 | + break; |
| 113 | + case 'constraint_primary_key': |
| 114 | + column.push('PRIMARY KEY'); |
| 115 | + break; |
| 116 | + default: |
| 117 | + throw new Error( |
| 118 | + `Don't know how to serialize constraint ${constraint.type} for column '${item.name.name}'`, |
| 119 | + ); |
| 120 | + } |
| 121 | + } |
| 122 | + |
| 123 | + columns.push(column.join(' ')); |
| 124 | + } |
| 125 | + sql.push([...columns, makePrimaryKeyConstraint(cst, tableName)].join(',\n')); |
| 126 | +} |
| 127 | + |
| 128 | +function makePrimaryKeyConstraint(cst: Program, tableName: string): string { |
| 129 | + let alterTableStmts = cst.statements.filter( |
| 130 | + (s) => |
| 131 | + s.type === 'alter_table_stmt' && |
| 132 | + s.table.type === 'table_without_inheritance' && |
| 133 | + s.table.table.type === 'member_expr' && |
| 134 | + s.table.table.property.type === 'identifier' && |
| 135 | + s.table.table.property.name === tableName, |
| 136 | + ) as AlterTableStmt[]; |
| 137 | + let pkConstraint: string[] = []; |
| 138 | + for (let alterTableStmt of alterTableStmts) { |
| 139 | + for (let item of alterTableStmt.actions.items) { |
| 140 | + if (item.type === 'alter_action_add_constraint') { |
| 141 | + switch (item.constraint.type) { |
| 142 | + case 'constraint_primary_key': { |
| 143 | + if (pkConstraint.length > 0) { |
| 144 | + throw new Error( |
| 145 | + `encountered multiple primary key constraints for table ${tableName}`, |
| 146 | + ); |
| 147 | + } |
| 148 | + if (item.constraint.columns) { |
| 149 | + let columns: string[] = []; |
| 150 | + if (item.constraint.columns.type === 'paren_expr') { |
| 151 | + for (let column of item.constraint.columns.expr.items) { |
| 152 | + if ( |
| 153 | + column.type === 'index_specification' && |
| 154 | + column.expr.type === 'identifier' |
| 155 | + ) { |
| 156 | + columns.push(column.expr.name); |
| 157 | + } |
| 158 | + } |
| 159 | + } else { |
| 160 | + throw new Error( |
| 161 | + `Don't know how to serialize constraint ${item.constraint.type} for table '${tableName}'`, |
| 162 | + ); |
| 163 | + } |
| 164 | + if (columns.length > 0) { |
| 165 | + pkConstraint.push( |
| 166 | + INDENT, |
| 167 | + 'PRIMARY KEY (', |
| 168 | + columns.join(', '), |
| 169 | + ')', |
| 170 | + ); |
| 171 | + } |
| 172 | + } |
| 173 | + break; |
| 174 | + } |
| 175 | + default: |
| 176 | + throw new Error( |
| 177 | + `Don't know how to serialize constraint ${item.constraint.type} for table '${tableName}'`, |
| 178 | + ); |
| 179 | + } |
| 180 | + } |
| 181 | + } |
| 182 | + } |
| 183 | + return pkConstraint.join(' '); |
| 184 | +} |
| 185 | + |
| 186 | +// This strips out all the things that our SQL AST chokes on (it's still in an |
| 187 | +// experimental phase for postgresql) |
| 188 | +function prepareDump(sql: string): string { |
| 189 | + let result = sql |
| 190 | + .replace(/\s*SET\s[^;].*;/gm, '') |
| 191 | + .replace(/\s*CREATE\sTYPE\s[^;]*;/gm, ''); |
| 192 | + return result; |
| 193 | +} |
| 194 | + |
| 195 | +function getSchemaFilename(): string { |
| 196 | + let files = readdirSync(migrationsDir); |
| 197 | + let lastFile = files |
| 198 | + .filter((f) => f !== '.eslintrc.js') |
| 199 | + .sort() |
| 200 | + .pop()!; |
| 201 | + return `${lastFile.replace(/_.*/, '')}_schema.sql`; |
| 202 | +} |
0 commit comments