ether-code 0.1.0

package/generators/sql-generator.js

@@ -0,0 +1,988 @@
+const fs = require('fs')
+
+class SQLGenerator {
+  constructor(i18nPath = null) {
+    this.i18n = null
+    this.indent = 0
+    this.output = ''
+    this.keywordMap = {}
+    this.functionMap = {}
+    this.typeMap = {}
+    
+    if (i18nPath) {
+      this.loadI18n(i18nPath)
+    }
+  }
+
+  loadI18n(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    this.i18n = JSON.parse(content)
+    this.buildMaps()
+  }
+
+  buildMaps() {
+    this.keywordMap = {}
+    this.functionMap = {}
+    this.typeMap = {}
+    
+    if (!this.i18n) return
+
+    const addToMap = (map, section) => {
+      if (!section) return
+      for (const [key, translations] of Object.entries(section)) {
+        if (translations && translations.fr && translations.sql) {
+          map[translations.fr.toLowerCase()] = translations.sql
+        }
+      }
+    }
+
+    for (const sectionName of Object.keys(this.i18n)) {
+      addToMap(this.keywordMap, this.i18n[sectionName])
+    }
+  }
+
+  translate(word) {
+    if (!word) return ''
+    const lower = word.toLowerCase()
+    return this.keywordMap[lower] || this.translateGeneric(word)
+  }
+
+  translateGeneric(word) {
+    const translations = {
+      'sélectionner': 'SELECT',
+      'depuis': 'FROM',
+      'ou': 'WHERE',
+      'et': 'AND',
+      'ou logique': 'OR',
+      'non': 'NOT',
+      'comme': 'AS',
+      'joindre': 'JOIN',
+      'gauche': 'LEFT',
+      'droite': 'RIGHT',
+      'interne': 'INNER',
+      'externe': 'OUTER',
+      'sur': 'ON',
+      'grouper par': 'GROUP BY',
+      'trier par': 'ORDER BY',
+      'ascendant': 'ASC',
+      'descendant': 'DESC',
+      'limite': 'LIMIT',
+      'decalage': 'OFFSET',
+      'avoir': 'HAVING',
+      'distinct': 'DISTINCT',
+      'tout': 'ALL',
+      'union': 'UNION',
+      'intersection': 'INTERSECT',
+      'difference': 'EXCEPT',
+      'insérer': 'INSERT',
+      'dans': 'INTO',
+      'valeurs': 'VALUES',
+      'mettre a jour': 'UPDATE',
+      'définir': 'SET',
+      'supprimer': 'DELETE',
+      'créer': 'CREATE',
+      'table': 'TABLE',
+      'base de données': 'DATABASE',
+      'schema': 'SCHEMA',
+      'index': 'INDEX',
+      'vue': 'VIEW',
+      'modifier': 'ALTER',
+      'ajouter': 'ADD',
+      'supprimer colonne': 'DROP',
+      'renommer': 'RENAME',
+      'vers': 'TO',
+      'colonne': 'COLUMN',
+      'contrainte': 'CONSTRAINT',
+      'clé primaire': 'PRIMARY KEY',
+      'clé etrangere': 'FOREIGN KEY',
+      'références': 'REFERENCES',
+      'unique': 'UNIQUE',
+      'non nul': 'NOT NULL',
+      'par défaut': 'DEFAULT',
+      'verification': 'CHECK',
+      'cascade': 'CASCADE',
+      'définir null': 'SET NULL',
+      'définir défaut': 'SET DEFAULT',
+      'restreindre': 'RESTRICT',
+      'pas action': 'NO ACTION',
+      'avec': 'WITH',
+      'si existe': 'IF EXISTS',
+      'si non existe': 'IF NOT EXISTS',
+      'temporaire': 'TEMPORARY',
+      'existe': 'EXISTS',
+      'dans liste': 'IN',
+      'entre': 'BETWEEN',
+      'similaire': 'LIKE',
+      'ilike': 'ILIKE',
+      'est nul': 'IS NULL',
+      'est non nul': 'IS NOT NULL',
+      'cas': 'CASE',
+      'quand': 'WHEN',
+      'alors': 'THEN',
+      'sinon': 'ELSE',
+      'fin': 'END',
+      'coalescence': 'COALESCE',
+      'si null': 'NULLIF',
+      'convertir': 'CAST',
+      'compter': 'COUNT',
+      'somme': 'SUM',
+      'moyenne': 'AVG',
+      'minimum': 'MIN',
+      'maximum': 'MAX',
+      'maintenant': 'NOW()',
+      'date actuelle': 'CURRENT_DATE',
+      'heure actuelle': 'CURRENT_TIME',
+      'horodatage actuel': 'CURRENT_TIMESTAMP',
+      'extraire': 'EXTRACT',
+      'année': 'YEAR',
+      'mois': 'MONTH',
+      'jour': 'DAY',
+      'heure': 'HOUR',
+      'minute': 'MINUTE',
+      'seconde': 'SECOND',
+      'concatener': 'CONCAT',
+      'longueur': 'LENGTH',
+      'majuscules': 'UPPER',
+      'minuscules': 'LOWER',
+      'supprimer espaces': 'TRIM',
+      'sous chaîne': 'SUBSTRING',
+      'remplacer': 'REPLACE',
+      'position': 'POSITION',
+      'arrondir': 'ROUND',
+      'plancher': 'FLOOR',
+      'plafond': 'CEIL',
+      'absolu': 'ABS',
+      'puissance': 'POWER',
+      'racine carree': 'SQRT',
+      'vrai': 'TRUE',
+      'faux': 'FALSE',
+      'nul': 'NULL',
+      'entier': 'INTEGER',
+      'petit entier': 'SMALLINT',
+      'grand entier': 'BIGINT',
+      'decimal': 'DECIMAL',
+      'numerique': 'NUMERIC',
+      'reel': 'REAL',
+      'double précision': 'DOUBLE PRECISION',
+      'texte': 'TEXT',
+      'caractère variable': 'VARCHAR',
+      'caractère': 'CHAR',
+      'booléen': 'BOOLEAN',
+      'type date': 'DATE',
+      'temps': 'TIME',
+      'horodatage': 'TIMESTAMP',
+      'intervalle': 'INTERVAL',
+      'json': 'JSON',
+      'jsonb': 'JSONB',
+      'uuid': 'UUID',
+      'tableau': 'ARRAY',
+      'serial': 'SERIAL',
+      'grand serial': 'BIGSERIAL',
+      'commencer': 'BEGIN',
+      'valider': 'COMMIT',
+      'annuler': 'ROLLBACK',
+      'point sauvegarde': 'SAVEPOINT',
+      'transaction': 'TRANSACTION',
+      'accorder': 'GRANT',
+      'revoquer': 'REVOKE',
+      'sur table': 'ON',
+      'type role': 'ROLE',
+      'utilisateur': 'USER',
+      'public': 'PUBLIC',
+      'sélection': 'SELECT',
+      'insertion': 'INSERT',
+      'mise a jour': 'UPDATE',
+      'suppression': 'DELETE',
+      'tous privileges': 'ALL PRIVILEGES',
+      'expliquer': 'EXPLAIN',
+      'analyser': 'ANALYZE',
+      'vide': 'VACUUM',
+      'reindexer': 'REINDEX'
+    }
+
+    const lower = word.toLowerCase()
+    return translations[lower] || word
+  }
+
+  generate(ast) {
+    this.output = ''
+    this.indent = 0
+
+    if (Array.isArray(ast)) {
+      for (const node of ast) {
+        this.generateNode(node)
+        this.output += ';\n\n'
+      }
+    } else if (ast && ast.type) {
+      this.generateNode(ast)
+      this.output += ';'
+    } else if (ast && ast.statements) {
+      for (const stmt of ast.statements) {
+        this.generateNode(stmt)
+        this.output += ';\n\n'
+      }
+    }
+
+    return this.output.trim()
+  }
+
+  generateNode(node) {
+    if (!node) return ''
+
+    switch (node.type) {
+      case 'SelectStatement':
+        return this.generateSelect(node)
+      case 'InsertStatement':
+        return this.generateInsert(node)
+      case 'UpdateStatement':
+        return this.generateUpdate(node)
+      case 'DeleteStatement':
+        return this.generateDelete(node)
+      case 'CreateTableStatement':
+        return this.generateCreateTable(node)
+      case 'AlterTableStatement':
+        return this.generateAlterTable(node)
+      case 'DropStatement':
+        return this.generateDrop(node)
+      case 'CreateIndexStatement':
+        return this.generateCreateIndex(node)
+      case 'CreateViewStatement':
+        return this.generateCreateView(node)
+      case 'TransactionStatement':
+        return this.generateTransaction(node)
+      case 'GrantStatement':
+        return this.generateGrant(node)
+      case 'RevokeStatement':
+        return this.generateRevoke(node)
+      case 'WithStatement':
+        return this.generateWith(node)
+      case 'UnionStatement':
+        return this.generateUnion(node)
+      default:
+        return ''
+    }
+  }
+
+  generateSelect(node) {
+    let sql = 'SELECT'
+
+    if (node.distinct) {
+      sql += ' DISTINCT'
+    }
+
+    const columns = (node.columns || ['*']).map(c => this.generateColumn(c))
+    sql += ' ' + columns.join(', ')
+
+    if (node.from) {
+      sql += '\nFROM ' + this.generateFrom(node.from)
+    }
+
+    if (node.joins && node.joins.length > 0) {
+      for (const join of node.joins) {
+        sql += '\n' + this.generateJoin(join)
+      }
+    }
+
+    if (node.where) {
+      sql += '\nWHERE ' + this.generateCondition(node.where)
+    }
+
+    if (node.groupBy && node.groupBy.length > 0) {
+      sql += '\nGROUP BY ' + node.groupBy.map(g => this.generateExpression(g)).join(', ')
+    }
+
+    if (node.having) {
+      sql += '\nHAVING ' + this.generateCondition(node.having)
+    }
+
+    if (node.orderBy && node.orderBy.length > 0) {
+      sql += '\nORDER BY ' + node.orderBy.map(o => this.generateOrderBy(o)).join(', ')
+    }
+
+    if (node.limit !== undefined) {
+      sql += '\nLIMIT ' + node.limit
+    }
+
+    if (node.offset !== undefined) {
+      sql += ' OFFSET ' + node.offset
+    }
+
+    this.output += sql
+    return sql
+  }
+
+  generateColumn(col) {
+    if (typeof col === 'string') {
+      return this.translate(col)
+    }
+    
+    let result = this.generateExpression(col.expression || col)
+    
+    if (col.alias) {
+      result += ' AS ' + this.translate(col.alias)
+    }
+    
+    return result
+  }
+
+  generateFrom(from) {
+    if (typeof from === 'string') {
+      return this.translate(from)
+    }
+    
+    if (from.subquery) {
+      return '(' + this.generateSelect(from.subquery) + ')' + 
+             (from.alias ? ' AS ' + from.alias : '')
+    }
+    
+    let result = this.translate(from.table || from.name)
+    if (from.alias) {
+      result += ' AS ' + from.alias
+    }
+    return result
+  }
+
+  generateJoin(join) {
+    let type = ''
+    switch (join.type?.toLowerCase()) {
+      case 'gauche':
+      case 'left':
+        type = 'LEFT JOIN'
+        break
+      case 'droite':
+      case 'right':
+        type = 'RIGHT JOIN'
+        break
+      case 'interne':
+      case 'inner':
+        type = 'INNER JOIN'
+        break
+      case 'externe':
+      case 'outer':
+      case 'complet':
+      case 'full':
+        type = 'FULL OUTER JOIN'
+        break
+      case 'croise':
+      case 'cross':
+        type = 'CROSS JOIN'
+        break
+      default:
+        type = 'JOIN'
+    }
+
+    let result = type + ' ' + this.generateFrom(join.table)
+    
+    if (join.on) {
+      result += ' ON ' + this.generateCondition(join.on)
+    }
+    
+    if (join.using) {
+      result += ' USING (' + join.using.join(', ') + ')'
+    }
+    
+    return result
+  }
+
+  generateCondition(cond) {
+    if (typeof cond === 'string') {
+      return cond
+    }
+
+    if (cond.and) {
+      return cond.and.map(c => '(' + this.generateCondition(c) + ')').join(' AND ')
+    }
+
+    if (cond.or) {
+      return cond.or.map(c => '(' + this.generateCondition(c) + ')').join(' OR ')
+    }
+
+    if (cond.not) {
+      return 'NOT (' + this.generateCondition(cond.not) + ')'
+    }
+
+    const left = this.generateExpression(cond.left || cond.column)
+    const op = this.translateOperator(cond.operator || cond.op)
+    const right = this.generateExpression(cond.right || cond.value)
+
+    if (op === 'IS NULL' || op === 'IS NOT NULL') {
+      return `${left} ${op}`
+    }
+
+    if (op === 'IN' || op === 'NOT IN') {
+      const values = Array.isArray(right) ? right.join(', ') : right
+      return `${left} ${op} (${values})`
+    }
+
+    if (op === 'BETWEEN') {
+      return `${left} BETWEEN ${this.generateExpression(cond.low)} AND ${this.generateExpression(cond.high)}`
+    }
+
+    return `${left} ${op} ${right}`
+  }
+
+  translateOperator(op) {
+    const operators = {
+      'egal': '=',
+      'different': '!=',
+      'superieur': '>',
+      'inferieur': '<',
+      'superieur ou egal': '>=',
+      'inferieur ou egal': '<=',
+      'similaire': 'LIKE',
+      'ilike': 'ILIKE',
+      'dans': 'IN',
+      'pas dans': 'NOT IN',
+      'entre': 'BETWEEN',
+      'est nul': 'IS NULL',
+      'est non nul': 'IS NOT NULL',
+      'contient': '@>',
+      'contenu dans': '<@'
+    }
+    return operators[op?.toLowerCase()] || op
+  }
+
+  generateExpression(expr) {
+    if (expr === null || expr === undefined) return 'NULL'
+    if (typeof expr === 'number') return String(expr)
+    if (typeof expr === 'boolean') return expr ? 'TRUE' : 'FALSE'
+    if (typeof expr === 'string') {
+      if (expr.toLowerCase() === 'true') return 'TRUE'
+      if (expr.toLowerCase() === 'false') return 'FALSE'
+      if (expr.startsWith("'") || expr.startsWith('"')) return expr
+      if (/^\d+$/.test(expr)) return expr
+      return this.translate(expr)
+    }
+
+    if (expr.type === 'function' || expr.function) {
+      return this.generateFunction(expr)
+    }
+
+    if (expr.type === 'case') {
+      return this.generateCase(expr)
+    }
+
+    if (expr.type === 'subquery') {
+      return '(' + this.generateSelect(expr.query) + ')'
+    }
+
+    if (expr.literal !== undefined) {
+      return this.generateLiteral(expr.literal)
+    }
+
+    if (expr.column) {
+      let result = ''
+      if (expr.table) {
+        result = expr.table + '.'
+      }
+      result += this.translate(expr.column)
+      return result
+    }
+
+    return String(expr)
+  }
+
+  generateFunction(func) {
+    const name = this.translate(func.name || func.function)
+    const args = (func.arguments || func.args || []).map(a => this.generateExpression(a))
+    
+    let result = name + '(' + args.join(', ') + ')'
+    
+    if (func.over) {
+      result += ' OVER (' + this.generateWindow(func.over) + ')'
+    }
+    
+    return result
+  }
+
+  generateWindow(window) {
+    let parts = []
+    
+    if (window.partitionBy) {
+      parts.push('PARTITION BY ' + window.partitionBy.map(p => this.generateExpression(p)).join(', '))
+    }
+    
+    if (window.orderBy) {
+      parts.push('ORDER BY ' + window.orderBy.map(o => this.generateOrderBy(o)).join(', '))
+    }
+    
+    return parts.join(' ')
+  }
+
+  generateCase(caseExpr) {
+    let sql = 'CASE'
+    
+    if (caseExpr.expression) {
+      sql += ' ' + this.generateExpression(caseExpr.expression)
+    }
+    
+    for (const when of caseExpr.whens || []) {
+      sql += ' WHEN ' + this.generateCondition(when.condition)
+      sql += ' THEN ' + this.generateExpression(when.result)
+    }
+    
+    if (caseExpr.else !== undefined) {
+      sql += ' ELSE ' + this.generateExpression(caseExpr.else)
+    }
+    
+    sql += ' END'
+    return sql
+  }
+
+  generateOrderBy(order) {
+    let result = this.generateExpression(order.column || order.expression || order)
+    
+    if (order.direction) {
+      const dir = order.direction.toLowerCase()
+      result += dir === 'desc' || dir === 'descendant' ? ' DESC' : ' ASC'
+    }
+    
+    if (order.nulls) {
+      result += order.nulls === 'first' ? ' NULLS FIRST' : ' NULLS LAST'
+    }
+    
+    return result
+  }
+
+  generateLiteral(value) {
+    if (value === null) return 'NULL'
+    if (typeof value === 'number') return String(value)
+    if (typeof value === 'boolean') return value ? 'TRUE' : 'FALSE'
+    if (typeof value === 'string') {
+      return "'" + value.replace(/'/g, "''") + "'"
+    }
+    if (Array.isArray(value)) {
+      return 'ARRAY[' + value.map(v => this.generateLiteral(v)).join(', ') + ']'
+    }
+    return String(value)
+  }
+
+  generateInsert(node) {
+    let sql = 'INSERT INTO ' + this.translate(node.table)
+
+    if (node.columns && node.columns.length > 0) {
+      sql += ' (' + node.columns.map(c => this.translate(c)).join(', ') + ')'
+    }
+
+    if (node.values) {
+      sql += '\nVALUES'
+      const rows = node.values.map(row => {
+        const vals = row.map(v => this.generateLiteral(v))
+        return '(' + vals.join(', ') + ')'
+      })
+      sql += ' ' + rows.join(',\n       ')
+    }
+
+    if (node.select) {
+      sql += '\n' + this.generateSelect(node.select)
+    }
+
+    if (node.onConflict) {
+      sql += '\nON CONFLICT '
+      if (node.onConflict.columns) {
+        sql += '(' + node.onConflict.columns.join(', ') + ') '
+      }
+      if (node.onConflict.doNothing) {
+        sql += 'DO NOTHING'
+      } else if (node.onConflict.doUpdate) {
+        sql += 'DO UPDATE SET '
+        const updates = Object.entries(node.onConflict.doUpdate).map(([k, v]) => 
+          this.translate(k) + ' = ' + this.generateExpression(v)
+        )
+        sql += updates.join(', ')
+      }
+    }
+
+    if (node.returning) {
+      sql += '\nRETURNING ' + node.returning.map(c => this.generateColumn(c)).join(', ')
+    }
+
+    this.output += sql
+    return sql
+  }
+
+  generateUpdate(node) {
+    let sql = 'UPDATE ' + this.translate(node.table)
+
+    sql += '\nSET '
+    const sets = Object.entries(node.set || {}).map(([k, v]) =>
+      this.translate(k) + ' = ' + this.generateExpression(v)
+    )
+    sql += sets.join(',\n    ')
+
+    if (node.from) {
+      sql += '\nFROM ' + this.generateFrom(node.from)
+    }
+
+    if (node.where) {
+      sql += '\nWHERE ' + this.generateCondition(node.where)
+    }
+
+    if (node.returning) {
+      sql += '\nRETURNING ' + node.returning.map(c => this.generateColumn(c)).join(', ')
+    }
+
+    this.output += sql
+    return sql
+  }
+
+  generateDelete(node) {
+    let sql = 'DELETE FROM ' + this.translate(node.table)
+
+    if (node.using) {
+      sql += '\nUSING ' + this.generateFrom(node.using)
+    }
+
+    if (node.where) {
+      sql += '\nWHERE ' + this.generateCondition(node.where)
+    }
+
+    if (node.returning) {
+      sql += '\nRETURNING ' + node.returning.map(c => this.generateColumn(c)).join(', ')
+    }
+
+    this.output += sql
+    return sql
+  }
+
+  generateCreateTable(node) {
+    let sql = 'CREATE'
+    
+    if (node.temporary) sql += ' TEMPORARY'
+    
+    sql += ' TABLE'
+    
+    if (node.ifNotExists) sql += ' IF NOT EXISTS'
+    
+    sql += ' ' + this.translate(node.table)
+    sql += ' (\n'
+
+    const columns = (node.columns || []).map(col => this.generateColumnDef(col))
+    const constraints = (node.constraints || []).map(c => this.generateConstraint(c))
+    
+    sql += '  ' + [...columns, ...constraints].join(',\n  ')
+    sql += '\n)'
+
+    this.output += sql
+    return sql
+  }
+
+  generateColumnDef(col) {
+    let def = this.translate(col.name) + ' ' + this.translate(col.type)
+    
+    if (col.length) {
+      def += '(' + col.length + ')'
+    }
+    
+    if (col.precision) {
+      def += '(' + col.precision + (col.scale ? ', ' + col.scale : '') + ')'
+    }
+    
+    if (col.array) {
+      def += '[]'
+    }
+    
+    if (col.primaryKey) {
+      def += ' PRIMARY KEY'
+    }
+    
+    if (col.notNull || col.required) {
+      def += ' NOT NULL'
+    }
+    
+    if (col.unique) {
+      def += ' UNIQUE'
+    }
+    
+    if (col.default !== undefined) {
+      def += ' DEFAULT ' + this.generateExpression(col.default)
+    }
+    
+    if (col.references) {
+      def += ' REFERENCES ' + col.references.table
+      if (col.references.column) {
+        def += '(' + col.references.column + ')'
+      }
+      if (col.references.onDelete) {
+        def += ' ON DELETE ' + col.references.onDelete.toUpperCase()
+      }
+      if (col.references.onUpdate) {
+        def += ' ON UPDATE ' + col.references.onUpdate.toUpperCase()
+      }
+    }
+    
+    if (col.check) {
+      def += ' CHECK (' + this.generateCondition(col.check) + ')'
+    }
+    
+    return def
+  }
+
+  generateConstraint(constraint) {
+    let sql = ''
+    
+    if (constraint.name) {
+      sql += 'CONSTRAINT ' + constraint.name + ' '
+    }
+    
+    switch (constraint.type?.toLowerCase()) {
+      case 'primary key':
+      case 'clé primaire':
+        sql += 'PRIMARY KEY (' + constraint.columns.join(', ') + ')'
+        break
+      case 'foreign key':
+      case 'clé etrangere':
+        sql += 'FOREIGN KEY (' + constraint.columns.join(', ') + ')'
+        sql += ' REFERENCES ' + constraint.references.table
+        sql += '(' + constraint.references.columns.join(', ') + ')'
+        if (constraint.references.onDelete) {
+          sql += ' ON DELETE ' + constraint.references.onDelete.toUpperCase()
+        }
+        break
+      case 'unique':
+        sql += 'UNIQUE (' + constraint.columns.join(', ') + ')'
+        break
+      case 'check':
+      case 'verification':
+        sql += 'CHECK (' + this.generateCondition(constraint.condition) + ')'
+        break
+    }
+    
+    return sql
+  }
+
+  generateAlterTable(node) {
+    let sql = 'ALTER TABLE ' + this.translate(node.table)
+    
+    const actions = (node.actions || [node.action]).map(action => {
+      switch (action.type?.toLowerCase()) {
+        case 'add':
+        case 'ajouter':
+          if (action.column) {
+            return 'ADD COLUMN ' + this.generateColumnDef(action.column)
+          }
+          if (action.constraint) {
+            return 'ADD ' + this.generateConstraint(action.constraint)
+          }
+          break
+        case 'drop':
+        case 'supprimer':
+          if (action.column) {
+            return 'DROP COLUMN ' + action.column
+          }
+          if (action.constraint) {
+            return 'DROP CONSTRAINT ' + action.constraint
+          }
+          break
+        case 'alter':
+        case 'modifier':
+          let alter = 'ALTER COLUMN ' + action.column
+          if (action.dataType || action.newType) {
+            alter += ' TYPE ' + this.translate(action.dataType || action.newType)
+          }
+          if (action.setDefault !== undefined) {
+            alter += ' SET DEFAULT ' + this.generateExpression(action.setDefault)
+          }
+          if (action.dropDefault) {
+            alter += ' DROP DEFAULT'
+          }
+          if (action.setNotNull) {
+            alter += ' SET NOT NULL'
+          }
+          if (action.dropNotNull) {
+            alter += ' DROP NOT NULL'
+          }
+          return alter
+        case 'rename':
+        case 'renommer':
+          if (action.column) {
+            return 'RENAME COLUMN ' + action.column + ' TO ' + action.to
+          }
+          return 'RENAME TO ' + action.to
+      }
+      return ''
+    })
+    
+    sql += '\n  ' + actions.filter(a => a).join(',\n  ')
+
+    this.output += sql
+    return sql
+  }
+
+  generateDrop(node) {
+    let sql = 'DROP'
+    
+    sql += ' ' + (node.objectType || 'TABLE').toUpperCase()
+    
+    if (node.ifExists) {
+      sql += ' IF EXISTS'
+    }
+    
+    sql += ' ' + this.translate(node.name)
+    
+    if (node.cascade) {
+      sql += ' CASCADE'
+    }
+
+    this.output += sql
+    return sql
+  }
+
+  generateCreateIndex(node) {
+    let sql = 'CREATE'
+    
+    if (node.unique) sql += ' UNIQUE'
+    
+    sql += ' INDEX'
+    
+    if (node.concurrently) sql += ' CONCURRENTLY'
+    if (node.ifNotExists) sql += ' IF NOT EXISTS'
+    
+    sql += ' ' + node.name
+    sql += ' ON ' + this.translate(node.table)
+    
+    if (node.using) {
+      sql += ' USING ' + node.using.toUpperCase()
+    }
+    
+    sql += ' (' + node.columns.map(c => {
+      let col = typeof c === 'string' ? c : c.column
+      if (c.direction) col += ' ' + c.direction.toUpperCase()
+      return col
+    }).join(', ') + ')'
+    
+    if (node.where) {
+      sql += ' WHERE ' + this.generateCondition(node.where)
+    }
+
+    this.output += sql
+    return sql
+  }
+
+  generateCreateView(node) {
+    const savedOutput = this.output
+    this.output = ''
+    
+    let sql = 'CREATE'
+    
+    if (node.orReplace) sql += ' OR REPLACE'
+    if (node.temporary) sql += ' TEMPORARY'
+    
+    sql += ' VIEW ' + node.name
+    
+    if (node.columns && node.columns.length > 0) {
+      sql += ' (' + node.columns.join(', ') + ')'
+    }
+    
+    sql += ' AS\n'
+    this.output = ''
+    this.generateSelect(node.select)
+    sql += this.output.trim()
+
+    this.output = savedOutput + sql
+    return sql
+  }
+
+  generateTransaction(node) {
+    const action = (node.action || node.type || '').toLowerCase()
+    
+    switch (action) {
+      case 'begin':
+      case 'commencer':
+        this.output += 'BEGIN'
+        break
+      case 'commit':
+      case 'valider':
+        this.output += 'COMMIT'
+        break
+      case 'rollback':
+      case 'annuler':
+        this.output += 'ROLLBACK'
+        if (node.savepoint) {
+          this.output += ' TO SAVEPOINT ' + node.savepoint
+        }
+        break
+      case 'savepoint':
+      case 'point sauvegarde':
+        this.output += 'SAVEPOINT ' + node.name
+        break
+    }
+  }
+
+  generateGrant(node) {
+    let sql = 'GRANT '
+    
+    sql += (node.privileges || ['ALL']).join(', ')
+    sql += ' ON ' + (node.objectType || 'TABLE') + ' ' + node.object
+    sql += ' TO ' + node.grantee
+
+    this.output += sql
+    return sql
+  }
+
+  generateRevoke(node) {
+    let sql = 'REVOKE '
+    
+    sql += (node.privileges || ['ALL']).join(', ')
+    sql += ' ON ' + (node.objectType || 'TABLE') + ' ' + node.object
+    sql += ' FROM ' + node.grantee
+
+    this.output += sql
+    return sql
+  }
+
+  generateWith(node) {
+    const savedOutput = this.output
+    this.output = ''
+    
+    let sql = 'WITH '
+    
+    if (node.recursive) sql += 'RECURSIVE '
+    
+    const ctes = (node.ctes || []).map(cte => {
+      let cteSql = cte.name
+      if (cte.columns) {
+        cteSql += ' (' + cte.columns.join(', ') + ')'
+      }
+      cteSql += ' AS (\n'
+      this.output = ''
+      this.generateSelect(cte.query)
+      cteSql += this.output.trim()
+      cteSql += '\n)'
+      return cteSql
+    })
+    
+    sql += ctes.join(',\n')
+    sql += '\n'
+    this.output = ''
+    this.generateSelect(node.select)
+    sql += this.output.trim()
+
+    this.output = savedOutput + sql
+    return sql
+  }
+
+  generateUnion(node) {
+    const savedOutput = this.output
+    this.output = ''
+    
+    const queries = node.queries || [node.left, node.right]
+    const type = node.all ? 'UNION ALL' : 'UNION'
+    
+    const parts = []
+    for (const q of queries) {
+      this.output = ''
+      this.generateSelect(q)
+      parts.push(this.output.trim())
+    }
+    
+    const sql = parts.join('\n' + type + '\n')
+    
+    this.output = savedOutput + sql
+    return sql
+  }
+}
+
+module.exports = {
+  SQLGenerator
+}