ether-code 0.7.8 → 0.7.9

package/parsers/ether-parser-sql.js

@@ -0,0 +1,622 @@
+const { EtherParserBase, TokenType } = require('./ether-parser-base')
+
+class EtherParserSQL extends EtherParserBase {
+  constructor(options = {}) {
+    super(options)
+    this.loadI18n(['i18n-sql.json'])
+  }
+
+  parse(source) {
+    this.tokenize(source)
+    return this.parseSQLProgram()
+  }
+
+  parseSQLProgram() {
+    const program = {
+      type: 'SQLProgram',
+      statements: []
+    }
+    
+    this.skipNewlines()
+    
+    while (!this.isAtEnd()) {
+      const statement = this.parseSQLStatement()
+      if (statement) {
+        program.statements.push(statement)
+      }
+      this.skipNewlines()
+    }
+    
+    return program
+  }
+
+  parseSQLStatement() {
+    this.skipNewlines()
+    const token = this.current()
+    
+    if (!token || token.type === TokenType.EOF) return null
+    
+    const value = token.value ? token.value.toLowerCase() : ''
+    
+    if (value === 'selectionner' || value === 'select' || value === 'choisir') {
+      return this.parseSQLSelect()
+    }
+    
+    if (value === 'inserer' || value === 'insert' || value === 'ajouter') {
+      return this.parseSQLInsert()
+    }
+    
+    if (value === 'mettre' || value === 'update' || value === 'modifier') {
+      return this.parseSQLUpdate()
+    }
+    
+    if (value === 'supprimer' || value === 'delete' || value === 'effacer') {
+      return this.parseSQLDelete()
+    }
+    
+    if (value === 'creer' || value === 'create') {
+      return this.parseSQLCreate()
+    }
+    
+    if (value === 'detruire' || value === 'drop') {
+      return this.parseSQLDrop()
+    }
+    
+    if (value === 'modifier' || value === 'alter') {
+      return this.parseSQLAlter()
+    }
+    
+    this.advance()
+    return null
+  }
+
+  parseSQLSelect() {
+    this.advance()
+    
+    const columns = []
+    
+    while (!this.isAtEnd()) {
+      const token = this.current()
+      
+      if (!token || token.type === TokenType.EOF) break
+      
+      const value = token.value ? token.value.toLowerCase() : ''
+      if (value === 'depuis' || value === 'de' || value === 'from') break
+      
+      if (token.type === TokenType.STAR) {
+        columns.push('*')
+        this.advance()
+      } else if (token.type === TokenType.IDENTIFIER) {
+        columns.push(token.value)
+        this.advance()
+      } else if (token.type === TokenType.COMMA) {
+        this.advance()
+      } else {
+        break
+      }
+    }
+    
+    let table = null
+    if (this.matchValue('depuis') || this.matchValue('de') || this.matchValue('from')) {
+      const tableToken = this.current()
+      if (tableToken && tableToken.type === TokenType.IDENTIFIER) {
+        table = tableToken.value
+        this.advance()
+      }
+    }
+    
+    let where = null
+    if (this.matchValue('ou') || this.matchValue('where')) {
+      where = this.parseSQLWhere()
+    }
+    
+    let orderBy = null
+    if (this.matchValue('trier') || this.matchValue('ordonner') || this.matchValue('order')) {
+      if (this.matchValue('par') || this.matchValue('by')) {
+        orderBy = this.parseSQLOrderBy()
+      }
+    }
+    
+    let limit = null
+    if (this.matchValue('limiter') || this.matchValue('limit')) {
+      const limitToken = this.current()
+      if (limitToken && (limitToken.type === TokenType.NUMBER || limitToken.type === TokenType.INTEGER)) {
+        limit = parseInt(limitToken.value)
+        this.advance()
+      }
+    }
+    
+    return {
+      type: 'SelectStatement',
+      columns: columns,
+      table: table,
+      where: where,
+      orderBy: orderBy,
+      limit: limit
+    }
+  }
+
+  parseSQLWhere() {
+    const conditions = []
+    
+    while (!this.isAtEnd()) {
+      const token = this.current()
+      
+      if (!token || token.type === TokenType.EOF) break
+      
+      const value = token.value ? token.value.toLowerCase() : ''
+      if (value === 'trier' || value === 'ordonner' || value === 'order' || 
+          value === 'limiter' || value === 'limit' || value === 'grouper') break
+      
+      if (token.type === TokenType.IDENTIFIER) {
+        const field = token.value
+        this.advance()
+        
+        const opToken = this.current()
+        let operator = '='
+        
+        if (opToken) {
+          if (opToken.type === TokenType.EQUALS || opToken.type === TokenType.DOUBLE_EQUALS) {
+            operator = '='
+            this.advance()
+          } else if (opToken.type === TokenType.NOT_EQUALS) {
+            operator = '<>'
+            this.advance()
+          } else if (opToken.type === TokenType.LT) {
+            operator = '<'
+            this.advance()
+          } else if (opToken.type === TokenType.GT) {
+            operator = '>'
+            this.advance()
+          } else if (opToken.type === TokenType.LTE) {
+            operator = '<='
+            this.advance()
+          } else if (opToken.type === TokenType.GTE) {
+            operator = '>='
+            this.advance()
+          } else if (opToken.value && opToken.value.toLowerCase() === 'egal') {
+            operator = '='
+            this.advance()
+          }
+        }
+        
+        const valueToken = this.current()
+        let condValue = null
+        
+        if (valueToken) {
+          if (valueToken.type === TokenType.STRING) {
+            condValue = valueToken.value
+          } else if (valueToken.type === TokenType.NUMBER || valueToken.type === TokenType.INTEGER) {
+            condValue = parseFloat(valueToken.value)
+          } else if (valueToken.type === TokenType.IDENTIFIER) {
+            condValue = valueToken.value
+          }
+          this.advance()
+        }
+        
+        conditions.push({ field, operator, value: condValue })
+      } else if (value === 'et' || value === 'and') {
+        conditions.push({ type: 'AND' })
+        this.advance()
+      } else if (value === 'ou' || value === 'or') {
+        conditions.push({ type: 'OR' })
+        this.advance()
+      } else {
+        this.advance()
+      }
+    }
+    
+    return conditions
+  }
+
+  parseSQLOrderBy() {
+    const orders = []
+    
+    while (!this.isAtEnd()) {
+      const token = this.current()
+      
+      if (!token || token.type === TokenType.EOF) break
+      
+      const value = token.value ? token.value.toLowerCase() : ''
+      if (value === 'limiter' || value === 'limit' || value === 'grouper') break
+      
+      if (token.type === TokenType.IDENTIFIER) {
+        const field = token.value
+        this.advance()
+        
+        let direction = 'ASC'
+        const dirToken = this.current()
+        
+        if (dirToken) {
+          const dirValue = dirToken.value ? dirToken.value.toLowerCase() : ''
+          if (dirValue === 'desc' || dirValue === 'descendant' || dirValue === 'decroissant') {
+            direction = 'DESC'
+            this.advance()
+          } else if (dirValue === 'asc' || dirValue === 'ascendant' || dirValue === 'croissant') {
+            direction = 'ASC'
+            this.advance()
+          }
+        }
+        
+        orders.push({ field, direction })
+      } else if (token.type === TokenType.COMMA) {
+        this.advance()
+      } else {
+        break
+      }
+    }
+    
+    return orders
+  }
+
+  parseSQLInsert() {
+    this.advance()
+    
+    this.matchValue('dans') || this.matchValue('into') || this.matchValue('in')
+    
+    const tableToken = this.current()
+    let table = null
+    if (tableToken && tableToken.type === TokenType.IDENTIFIER) {
+      table = tableToken.value
+      this.advance()
+    }
+    
+    const columns = []
+    if (this.match(TokenType.LPAREN)) {
+      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
+        const colToken = this.current()
+        if (colToken && colToken.type === TokenType.IDENTIFIER) {
+          columns.push(colToken.value)
+          this.advance()
+        }
+        this.match(TokenType.COMMA)
+      }
+    }
+    
+    const values = []
+    if (this.matchValue('valeurs') || this.matchValue('values')) {
+      if (this.match(TokenType.LPAREN)) {
+        while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
+          const valToken = this.current()
+          if (valToken) {
+            if (valToken.type === TokenType.STRING) {
+              values.push(valToken.value)
+            } else if (valToken.type === TokenType.NUMBER || valToken.type === TokenType.INTEGER) {
+              values.push(parseFloat(valToken.value))
+            } else if (valToken.type === TokenType.IDENTIFIER) {
+              const v = valToken.value.toLowerCase()
+              if (v === 'vrai' || v === 'true') values.push(true)
+              else if (v === 'faux' || v === 'false') values.push(false)
+              else if (v === 'nul' || v === 'null') values.push(null)
+              else values.push(valToken.value)
+            }
+            this.advance()
+          }
+          this.match(TokenType.COMMA)
+        }
+      }
+    }
+    
+    return {
+      type: 'InsertStatement',
+      table: table,
+      columns: columns,
+      values: values
+    }
+  }
+
+  parseSQLUpdate() {
+    this.advance()
+    
+    this.matchValue('a jour') || this.matchValue('jour')
+    
+    const tableToken = this.current()
+    let table = null
+    if (tableToken && tableToken.type === TokenType.IDENTIFIER) {
+      table = tableToken.value
+      this.advance()
+    }
+    
+    const assignments = []
+    if (this.matchValue('definir') || this.matchValue('set') || this.matchValue('avec')) {
+      while (!this.isAtEnd()) {
+        const colToken = this.current()
+        
+        if (!colToken || colToken.type === TokenType.EOF) break
+        
+        const value = colToken.value ? colToken.value.toLowerCase() : ''
+        if (value === 'ou' || value === 'where') break
+        
+        if (colToken.type === TokenType.IDENTIFIER) {
+          const column = colToken.value
+          this.advance()
+          
+          if (this.match(TokenType.EQUALS) || this.match(TokenType.COLON)) {
+            const valToken = this.current()
+            let val = null
+            
+            if (valToken) {
+              if (valToken.type === TokenType.STRING) {
+                val = valToken.value
+              } else if (valToken.type === TokenType.NUMBER || valToken.type === TokenType.INTEGER) {
+                val = parseFloat(valToken.value)
+              } else if (valToken.type === TokenType.IDENTIFIER) {
+                val = valToken.value
+              }
+              this.advance()
+            }
+            
+            assignments.push({ column, value: val })
+          }
+        }
+        
+        this.match(TokenType.COMMA)
+      }
+    }
+    
+    let where = null
+    if (this.matchValue('ou') || this.matchValue('where')) {
+      where = this.parseSQLWhere()
+    }
+    
+    return {
+      type: 'UpdateStatement',
+      table: table,
+      assignments: assignments,
+      where: where
+    }
+  }
+
+  parseSQLDelete() {
+    this.advance()
+    
+    this.matchValue('de') || this.matchValue('depuis') || this.matchValue('from')
+    
+    const tableToken = this.current()
+    let table = null
+    if (tableToken && tableToken.type === TokenType.IDENTIFIER) {
+      table = tableToken.value
+      this.advance()
+    }
+    
+    let where = null
+    if (this.matchValue('ou') || this.matchValue('where')) {
+      where = this.parseSQLWhere()
+    }
+    
+    return {
+      type: 'DeleteStatement',
+      table: table,
+      where: where
+    }
+  }
+
+  parseSQLCreate() {
+    this.advance()
+    
+    if (this.matchValue('table')) {
+      return this.parseSQLCreateTable()
+    }
+    
+    if (this.matchValue('base') || this.matchValue('database')) {
+      this.matchValue('de')
+      this.matchValue('donnees')
+      return this.parseSQLCreateDatabase()
+    }
+    
+    if (this.matchValue('index')) {
+      return this.parseSQLCreateIndex()
+    }
+    
+    return null
+  }
+
+  parseSQLCreateTable() {
+    const nameToken = this.current()
+    let name = null
+    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
+      name = nameToken.value
+      this.advance()
+    }
+    
+    const columns = []
+    
+    this.skipNewlines()
+    if (this.match(TokenType.INDENT)) {
+      while (!this.isAtEnd()) {
+        const current = this.current()
+        
+        if (current && current.type === TokenType.DEDENT) {
+          this.advance()
+          break
+        }
+        
+        if (current && current.type === TokenType.NEWLINE) {
+          this.advance()
+          continue
+        }
+        
+        const col = this.parseSQLColumnDef()
+        if (col) {
+          columns.push(col)
+        }
+      }
+    }
+    
+    return {
+      type: 'CreateTableStatement',
+      name: name,
+      columns: columns
+    }
+  }
+
+  parseSQLColumnDef() {
+    const nameToken = this.current()
+    if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) return null
+    
+    const name = nameToken.value
+    this.advance()
+    
+    let dataType = 'TEXT'
+    const typeToken = this.current()
+    if (typeToken && typeToken.type === TokenType.IDENTIFIER) {
+      const typeMap = {
+        'entier': 'INTEGER',
+        'texte': 'TEXT',
+        'reel': 'REAL',
+        'booleen': 'BOOLEAN',
+        'date': 'DATE',
+        'horodatage': 'TIMESTAMP'
+      }
+      dataType = typeMap[typeToken.value.toLowerCase()] || typeToken.value.toUpperCase()
+      this.advance()
+    }
+    
+    const constraints = []
+    while (!this.isAtEnd()) {
+      const token = this.current()
+      if (!token || token.type === TokenType.NEWLINE || token.type === TokenType.COMMA || token.type === TokenType.DEDENT) break
+      
+      const val = token.value ? token.value.toLowerCase() : ''
+      
+      if (val === 'cle' || val === 'primaire' || val === 'primary') {
+        constraints.push('PRIMARY KEY')
+        this.advance()
+        this.matchValue('primaire') || this.matchValue('key')
+      } else if (val === 'unique') {
+        constraints.push('UNIQUE')
+        this.advance()
+      } else if (val === 'non' || val === 'not') {
+        this.advance()
+        if (this.matchValue('nul') || this.matchValue('null')) {
+          constraints.push('NOT NULL')
+        }
+      } else if (val === 'auto') {
+        constraints.push('AUTOINCREMENT')
+        this.advance()
+        this.matchValue('increment')
+      } else {
+        break
+      }
+    }
+    
+    return {
+      name: name,
+      type: dataType,
+      constraints: constraints
+    }
+  }
+
+  parseSQLCreateDatabase() {
+    const nameToken = this.current()
+    let name = null
+    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
+      name = nameToken.value
+      this.advance()
+    }
+    
+    return {
+      type: 'CreateDatabaseStatement',
+      name: name
+    }
+  }
+
+  parseSQLCreateIndex() {
+    const nameToken = this.current()
+    let name = null
+    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
+      name = nameToken.value
+      this.advance()
+    }
+    
+    this.matchValue('sur') || this.matchValue('on')
+    
+    const tableToken = this.current()
+    let table = null
+    if (tableToken && tableToken.type === TokenType.IDENTIFIER) {
+      table = tableToken.value
+      this.advance()
+    }
+    
+    const columns = []
+    if (this.match(TokenType.LPAREN)) {
+      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
+        const colToken = this.current()
+        if (colToken && colToken.type === TokenType.IDENTIFIER) {
+          columns.push(colToken.value)
+          this.advance()
+        }
+        this.match(TokenType.COMMA)
+      }
+    }
+    
+    return {
+      type: 'CreateIndexStatement',
+      name: name,
+      table: table,
+      columns: columns
+    }
+  }
+
+  parseSQLDrop() {
+    this.advance()
+    
+    if (this.matchValue('table')) {
+      const nameToken = this.current()
+      let name = null
+      if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
+        name = nameToken.value
+        this.advance()
+      }
+      return { type: 'DropTableStatement', name: name }
+    }
+    
+    return null
+  }
+
+  parseSQLAlter() {
+    this.advance()
+    
+    if (this.matchValue('table')) {
+      const nameToken = this.current()
+      let name = null
+      if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
+        name = nameToken.value
+        this.advance()
+      }
+      
+      const operations = []
+      
+      while (!this.isAtEnd()) {
+        if (this.matchValue('ajouter') || this.matchValue('add')) {
+          this.matchValue('colonne') || this.matchValue('column')
+          const col = this.parseSQLColumnDef()
+          if (col) operations.push({ type: 'ADD', column: col })
+        } else if (this.matchValue('supprimer') || this.matchValue('drop')) {
+          this.matchValue('colonne') || this.matchValue('column')
+          const colToken = this.current()
+          if (colToken && colToken.type === TokenType.IDENTIFIER) {
+            operations.push({ type: 'DROP', column: colToken.value })
+            this.advance()
+          }
+        } else {
+          break
+        }
+      }
+      
+      return { type: 'AlterTableStatement', name: name, operations: operations }
+    }
+    
+    return null
+  }
+
+  parseStatement(lang) {
+    return this.parseSQLStatement()
+  }
+
+  parseExpression(lang) {
+    return null
+  }
+}
+
+module.exports = { EtherParserSQL }