get version result and login from oracle

plugins/dbgate-plugin-oracle/src/frontend/Dumper.js

@@ -0,0 +1,100 @@
+const { SqlDumper, arrayToHexString, testEqualTypes } = global.DBGATE_TOOLS;
+
+class Dumper extends SqlDumper {
+  /** @param type {import('dbgate-types').TransformType} */
+  transform(type, dumpExpr) {
+    switch (type) {
+      case 'GROUP:YEAR':
+      case 'YEAR':
+        this.put('^extract(^year ^from %c)', dumpExpr);
+        break;
+      case 'MONTH':
+        this.put('^extract(^month ^from %c)', dumpExpr);
+        break;
+      case 'DAY':
+        this.put('^extract(^day ^from %c)', dumpExpr);
+        break;
+      case 'GROUP:MONTH':
+        this.put("^to_char(%c, '%s')", dumpExpr, 'YYYY-MM');
+        break;
+      case 'GROUP:DAY':
+        this.put("^to_char(%c, '%s')", dumpExpr, 'YYYY-MM-DD');
+        break;
+      default:
+        dumpExpr();
+        break;
+    }
+  }
+
+  dropRecreatedTempTable(tmptable) {
+    this.putCmd('^drop ^table %i ^cascade', tmptable);
+  }
+
+  renameTable(obj, newname) {
+    this.putCmd('^alter ^table %f ^rename ^to %i', obj, newname);
+  }
+
+  renameColumn(column, newcol) {
+    this.putCmd('^alter ^table %f ^rename ^column %i ^to %i', column, column.columnName, newcol);
+  }
+
+  dropTable(obj, options = {}) {
+    this.put('^drop ^table');
+    if (options.testIfExists) this.put(' ^if ^exists');
+    this.put(' %f', obj);
+    this.endCommand();
+  }
+
+  //public override void CreateIndex(IndexInfo ix)
+  //{
+  //}
+
+  enableConstraints(table, enabled) {
+    this.putCmd('^alter ^table %f %k ^trigger ^all', table, enabled ? 'enable' : 'disable');
+  }
+
+  columnDefinition(col, options) {
+    if (col.autoIncrement) {
+      this.put('^serial');
+      return;
+    }
+    super.columnDefinition(col, options);
+  }
+
+  changeColumn(oldcol, newcol, constraints) {
+    if (oldcol.columnName != newcol.columnName) {
+      this.putCmd('^alter ^table %f ^rename ^column %i ^to %i', oldcol, oldcol.columnName, newcol.columnName);
+    }
+    if (!testEqualTypes(oldcol, newcol)) {
+      this.putCmd('^alter ^table %f ^alter ^column %i ^type %s', oldcol, newcol.columnName, newcol.dataType);
+    }
+    if (oldcol.notNull != newcol.notNull) {
+      if (newcol.notNull) this.putCmd('^alter ^table %f ^alter ^column %i ^set ^not ^null', newcol, newcol.columnName);
+      else this.putCmd('^alter ^table %f ^alter ^column %i ^drop ^not ^null', newcol, newcol.columnName);
+    }
+    if (oldcol.defaultValue != newcol.defaultValue) {
+      if (newcol.defaultValue == null) {
+        this.putCmd('^alter ^table %f ^alter ^column %i ^drop ^default', newcol, newcol.columnName);
+      } else {
+        this.putCmd(
+          '^alter ^table %f ^alter ^column %i ^set ^default %s',
+          newcol,
+          newcol.columnName,
+          newcol.defaultValue
+        );
+      }
+    }
+  }
+
+  putValue(value) {
+    if (value === true) this.putRaw('true');
+    else if (value === false) this.putRaw('false');
+    else super.putValue(value);
+  }
+
+  putByteArrayValue(value) {
+    this.putRaw(`e'\\\\x${arrayToHexString(value)}'`);
+  }
+}
+
+module.exports = Dumper;

plugins/dbgate-plugin-oracle/src/frontend/drivers.js

@@ -0,0 +1,200 @@
+const { driverBase } = global.DBGATE_TOOLS;
+const Dumper = require('./Dumper');
+const { oracleSplitterOptions } = require('dbgate-query-splitter/lib/options');
+
+const spatialTypes = ['GEOGRAPHY'];
+
+/** @type {import('dbgate-types').SqlDialect} */
+const dialect = {
+  rangeSelect: true,
+  ilike: true,
+  // stringEscapeChar: '\\',
+  stringEscapeChar: "'",
+  fallbackDataType: 'varchar',
+  anonymousPrimaryKey: true,
+  enableConstraintsPerTable: true,
+  dropColumnDependencies: ['dependencies'],
+  quoteIdentifier(s) {
+    return '"' + s + '"';
+  },
+  stringAgg: true,
+
+  createColumn: true,
+  dropColumn: true,
+  changeColumn: true,
+  createIndex: true,
+  dropIndex: true,
+  createForeignKey: true,
+  dropForeignKey: true,
+  createPrimaryKey: true,
+  dropPrimaryKey: true,
+  createUnique: true,
+  dropUnique: true,
+  createCheck: true,
+  dropCheck: true,
+
+  dropReferencesWhenDropTable: true,
+
+  predefinedDataTypes: [
+    'bigint',
+    'bigserial',
+    'bit',
+    'varbit',
+    'boolean',
+    'box',
+    'bytea',
+    'char(20)',
+    'varchar(250)',
+    'cidr',
+    'circle',
+    'date',
+    'double precision',
+    'inet',
+    'int',
+    'interval',
+    'json',
+    'jsonb',
+    'line',
+    'lseg',
+    'macaddr',
+    'macaddr8',
+    'money',
+    'numeric(10,2)',
+    'path',
+    'pg_lsn',
+    'pg_snapshot',
+    'point',
+    'polygon',
+    'real',
+    'smallint',
+    'smallserial',
+    'serial',
+    'text',
+    'time',
+    'timetz',
+    'timestamp',
+    'timestamptz',
+    'tsquery',
+    'tsvector',
+    'txid_snapshot',
+    'uuid',
+    'xml',
+  ],
+
+  createColumnViewExpression(columnName, dataType, source, alias) {
+    if (dataType && spatialTypes.includes(dataType.toUpperCase())) {
+      return {
+        exprType: 'call',
+        func: 'ST_AsText',
+        alias: alias || columnName,
+        args: [
+          {
+            exprType: 'column',
+            columnName,
+            source,
+          },
+        ],
+      };
+    }
+  },
+};
+
+const oracleDriverBase = {
+  ...driverBase,
+  dumperClass: Dumper,
+  dialect,
+  // showConnectionField: (field, values) =>
+  //   ['server', 'port', 'user', 'password', 'defaultDatabase', 'singleDatabase'].includes(field),
+  getQuerySplitterOptions: () => oracleSplitterOptions,
+  readOnlySessions: true,
+
+  databaseUrlPlaceholder: 'e.g. oracledb://user:password@localhost:1521',
+
+  showConnectionField: (field, values) => {
+    if (field == 'useDatabaseUrl') return true;
+    if (values.useDatabaseUrl) {
+      return ['databaseUrl', 'isReadOnly'].includes(field);
+    }
+
+    return (
+      ['authType', 'user', 'password', 'defaultDatabase', 'singleDatabase', 'isReadOnly'].includes(field) ||
+      (values.authType == 'socket' && ['socketPath'].includes(field)) ||
+      (values.authType != 'socket' && ['server', 'port'].includes(field))
+    );
+  },
+
+  beforeConnectionSave: connection => {
+    const { databaseUrl } = connection;
+    if (databaseUrl) {
+      const m = databaseUrl.match(/\/([^/]+)($|\?)/);
+      return {
+        ...connection,
+        singleDatabase: !!m,
+        defaultDatabase: m ? m[1] : null,
+      };
+    }
+    return connection;
+  },
+
+  __analyserInternals: {
+    refTableCond: '',
+  },
+
+  getNewObjectTemplates() {
+    return [
+      { label: 'New view', sql: 'CREATE VIEW myview\nAS\nSELECT * FROM table1' },
+      { label: 'New materialized view', sql: 'CREATE MATERIALIZED VIEW myview\nAS\nSELECT * FROM table1' },
+      {
+        label: 'New procedure',
+        sql: `CREATE PROCEDURE myproc (arg1 INT)
+LANGUAGE SQL
+AS $$
+  SELECT * FROM table1;
+$$`,
+      },
+      {
+        label: 'New function (plpgsql)',
+        sql: `CREATE FUNCTION myfunc (arg1 INT)
+RETURNS INT
+AS $$
+BEGIN
+  RETURN 1;
+END
+$$ LANGUAGE plpgsql;`,
+      },
+    ];
+  },
+
+  authTypeLabel: 'Connection mode',
+  defaultAuthTypeName: 'hostPort',
+  defaultSocketPath: '/var/run/oracledb',
+};
+
+/** @type {import('dbgate-types').EngineDriver} */
+const oracleDriver = {
+  ...oracleDriverBase,
+  engine: 'oracle@dbgate-plugin-oracle',
+  title: 'OracleDB',
+  defaultPort: 1521,
+  dialect: {
+    ...dialect,
+    materializedViews: true,
+  },
+
+  dialectByVersion(version) {
+    if (version) {
+      return {
+        ...dialect,
+        materializedViews:
+          version &&
+          version.versionMajor != null &&
+          version.versionMinor != null &&
+          (version.versionMajor > 9 || version.versionMajor == 9 || version.versionMinor >= 3),
+      };
+    }
+    return dialect;
+  },
+};
+
+
+module.exports = [oracleDriver];

plugins/dbgate-plugin-oracle/src/frontend/index.js

@@ -0,0 +1,6 @@
+import drivers from './drivers';
+
+export default {
+  packageName: 'dbgate-plugin-oracle',
+  drivers,
+};