sqlui 0.1.40 → 0.1.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69e4dde0aaa2c01991a06d6ac073494c10a22b6f55b4f40d0a7dedc5f5ab2e7a
-  data.tar.gz: 5321247d38c5845e5398b8cb6560e6581a389bac11cf9ea06e5ace893c7f0b5d
+  metadata.gz: a4307dfb13604d60040248f4a4135756f52310be559dfd3a65778e8400ab5454
+  data.tar.gz: 00ea3b80ba354e767521943cf83058cceebd53d5d3f112fdabc09952ee375471
 SHA512:
-  metadata.gz: 032dc0a5c4a53e8273b2cf9f2916dd3d322d2c10c2e3ccf9a067471cb029bdeed34c22889071220da9d91f83e4e3976c90ef2eeb8327c84a0de88675e60e9f33
-  data.tar.gz: 7a39174c4c5b2b19cd0adf03a51a522c40b577cac9cd16bfcce1cd32ede24816aa292cc8388d960172853c06420b56bba8193320650c5fa8bf26b40ebdabe3df
+  metadata.gz: 1aab467177964e30d47233e5f8e60922732de9cdb0238104dc7b74eecf9271ce80e3ac449c3afaac5c4ea91863160cd7edbf352b88cc8ae11274b738abe60271
+  data.tar.gz: 2d644c6ecd81b489acad2986be0d60f0dee3c20e5165943938279148af8f4f9f7a923a410bed570be71aad99b3f591ff92c050cd2a27df9ae06bdbb4b63ef8d7

data/.version

@@ -1 +1 @@
-0.1.40
+0.1.41

data/app/args.rb

@@ -24,6 +24,10 @@ class Args
     fetch_optional(hash, key, Hash)
   end
 
+  def self.fetch_optional_array(hash, key)
+    fetch_optional(hash, key, Array)
+  end
+
   def self.fetch_non_nil(hash, key, *classes)
     raise ArgumentError, "required parameter #{key} missing" unless hash.key?(key)
 

data/app/database_config.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'mysql2'
 require 'set'
 
@@ -7,7 +8,7 @@ require_relative 'args'
 
 # Config for a single database.
 class DatabaseConfig
-  attr_reader :display_name, :description, :url_path, :saved_path, :table_aliases, :client_params
+  attr_reader :display_name, :description, :url_path, :joins, :saved_path, :table_aliases, :client_params
 
   def initialize(hash)
     @display_name = Args.fetch_non_empty_string(hash, :display_name).strip
@@ -17,6 +18,15 @@ class DatabaseConfig
     raise ArgumentError, 'url_path should not end with a /' if @url_path.length > 1 && @url_path.end_with?('/')
 
     @saved_path = Args.fetch_non_empty_string(hash, :saved_path).strip
+    @joins = Args.fetch_optional_array(hash, :joins) || []
+    @joins.map do |join|
+      next if join.is_a?(Hash) &&
+              join.keys.size == 2 &&
+              join[:label].is_a?(String) && !join[:label].strip.empty? &&
+              join[:apply].is_a?(String) && !join[:apply].strip.empty?
+
+      raise ArgumentError, "invalid join #{join.to_json}"
+    end
     @table_aliases = Args.fetch_optional_hash(hash, :table_aliases) || {}
     @table_aliases = @table_aliases.each do |table, a|
       raise ArgumentError, "invalid alias for table #{table} (#{a}), expected string" unless a.is_a?(String)

data/app/database_metadata.rb

@@ -38,18 +38,17 @@ class DatabaseMetadata
             extra
           from information_schema.columns
           #{where_clause}
-          order by table_schema, table_name, column_name, ordinal_position;
+          order by table_schema, table_name, ordinal_position;
         SQL
       )
-      column_result.each do |row|
-        row = row.transform_keys(&:downcase).transform_keys(&:to_sym)
-        table_schema = row[:table_schema]
+      column_result.to_a.each do |row|
+        table_schema = row.shift
         unless result[table_schema]
           result[table_schema] = {
             tables: {}
           }
         end
-        table_name = row[:table_name]
+        table_name = row.shift
         tables = result[table_schema][:tables]
         unless tables[table_name]
           tables[table_name] = {
@@ -58,16 +57,16 @@ class DatabaseMetadata
           }
         end
         columns = result[table_schema][:tables][table_name][:columns]
-        column_name = row[:column_name]
+        column_name = row.shift
         columns[column_name] = {} unless columns[column_name]
         column = columns[column_name]
         column[:name] = column_name
-        column[:data_type] = row[:data_type]
-        column[:length] = row[:character_maximum_length]
-        column[:allow_null] = row[:is_nullable]
-        column[:key] = row[:column_key]
-        column[:default] = row[:column_default]
-        column[:extra] = row[:extra]
+        column[:data_type] = row.shift
+        column[:length] = row.shift
+        column[:allow_null] = row.shift
+        column[:key] = row.shift
+        column[:default] = row.shift
+        column[:extra] = row.shift
       end
       result
     end
@@ -86,30 +85,29 @@ class DatabaseMetadata
             table_schema,
             table_name,
             index_name,
+            column_name,
             seq_in_index,
-            non_unique,
-            column_name
+            non_unique
           from information_schema.statistics
           #{where_clause}
           order by table_schema, table_name, if(index_name = "PRIMARY", 0, index_name), seq_in_index;
       SQL
       )
       stats_result.each do |row|
-        row = row.transform_keys(&:downcase).transform_keys(&:to_sym)
-        table_schema = row[:table_schema]
+        table_schema = row.shift
         tables = result[table_schema][:tables]
-        table_name = row[:table_name]
+        table_name = row.shift
         indexes = tables[table_name][:indexes]
-        index_name = row[:index_name]
+        index_name = row.shift
         indexes[index_name] = {} unless indexes[index_name]
         index = indexes[index_name]
-        column_name = row[:column_name]
+        column_name = row.shift
         index[column_name] = {}
         column = index[column_name]
         column[:name] = index_name
-        column[:seq_in_index] = row[:seq_in_index]
-        column[:non_unique] = row[:non_unique]
-        column[:column_name] = row[:column_name]
+        column[:seq_in_index] = row.shift
+        column[:non_unique] = row.shift
+        column[:column_name] = column_name
       end
     end
   end

data/app/server.rb

@@ -12,6 +12,11 @@ require_relative 'sqlui'
 # SQLUI Sinatra server.
 class Server < Sinatra::Base
   def self.init_and_run(config, resources_dir)
+    Mysql2::Client.default_query_options[:as] = :array
+    Mysql2::Client.default_query_options[:cast_booleans] = true
+    Mysql2::Client.default_query_options[:database_timezone] = :utc
+    Mysql2::Client.default_query_options[:cache_rows] = false
+
     set :logging,         true
     set :bind,            '0.0.0.0'
     set :port,            config.port
@@ -58,6 +63,7 @@ class Server < Sinatra::Base
             list_url_path: config.list_url_path,
             schemas: DatabaseMetadata.lookup(client, database),
             table_aliases: database.table_aliases,
+            joins: database.joins,
             saved: Dir.glob("#{database.saved_path}/*.sql").to_h do |path|
               contents = File.read(path)
               comment_lines = contents.split("\n").take_while do |l|
@@ -164,8 +170,8 @@ class Server < Sinatra::Base
     # get a seg fault. Seems to be a bug in Mysql2.
     if result
       column_types = MysqlTypes.map_to_google_charts_types(result.field_types)
-      rows = result.map(&:values)
-      columns = result.first&.keys || []
+      rows = result.to_a
+      columns = result.fields
     else
       column_types = []
       rows = []

data/app/sqlui_config.rb

@@ -11,7 +11,7 @@ class SqluiConfig
   attr_reader :name, :port, :environment, :list_url_path, :database_configs
 
   def initialize(filename, overrides = {})
-    config = YAML.safe_load(ERB.new(File.read(filename)).result).deep_merge!(overrides)
+    config = YAML.safe_load(ERB.new(File.read(filename)).result, aliases: true).deep_merge!(overrides)
     config.deep_symbolize_keys!
     @name = Args.fetch_non_empty_string(config, :name).strip
     @port = Args.fetch_non_empty_int(config, :port)

data/client/resources/sqlui.js

@@ -3359,23 +3359,24 @@
        */
        minPointSize = -1) {
            let cursor = new SpanCursor(sets, null, minPointSize).goto(from), pos = from;
-           let open = cursor.openStart;
+           let openRanges = cursor.openStart;
            for (;;) {
                let curTo = Math.min(cursor.to, to);
                if (cursor.point) {
-                   iterator.point(pos, curTo, cursor.point, cursor.activeForPoint(cursor.to), open, cursor.pointRank);
-                   open = cursor.openEnd(curTo) + (cursor.to > curTo ? 1 : 0);
+                   let active = cursor.activeForPoint(cursor.to);
+                   let openCount = cursor.pointFrom < from ? active.length + 1 : Math.min(active.length, openRanges);
+                   iterator.point(pos, curTo, cursor.point, active, openCount, cursor.pointRank);
+                   openRanges = Math.min(cursor.openEnd(curTo), active.length);
                }
                else if (curTo > pos) {
-                   iterator.span(pos, curTo, cursor.active, open);
-                   open = cursor.openEnd(curTo);
+                   iterator.span(pos, curTo, cursor.active, openRanges);
+                   openRanges = cursor.openEnd(curTo);
                }
                if (cursor.to > to)
-                   break;
+                   return openRanges + (cursor.point && cursor.to > to ? 1 : 0);
                pos = cursor.to;
                cursor.next();
            }
-           return open;
        }
        /**
        Create a range set for the given range or array of ranges. By
@@ -3679,6 +3680,8 @@
            this.pointRank = 0;
            this.to = -1000000000 /* C.Far */;
            this.endSide = 0;
+           // The amount of open active ranges at the start of the iterator.
+           // Not including points.
            this.openStart = -1;
            this.cursor = HeapCursor.from(sets, skip, minPoint);
        }
@@ -3719,7 +3722,7 @@
        next() {
            let from = this.to, wasPoint = this.point;
            this.point = null;
-           let trackOpen = this.openStart < 0 ? [] : null, trackExtra = 0;
+           let trackOpen = this.openStart < 0 ? [] : null;
            for (;;) {
                let a = this.minActive;
                if (a > -1 && (this.activeTo[a] - this.cursor.from || this.active[a].endSide - this.cursor.startSide) < 0) {
@@ -3745,8 +3748,6 @@
                    let nextVal = this.cursor.value;
                    if (!nextVal.point) { // Opening a range
                        this.addActive(trackOpen);
-                       if (this.cursor.from < from && this.cursor.to > from)
-                           trackExtra++;
                        this.cursor.next();
                    }
                    else if (wasPoint && this.cursor.to == this.to && this.cursor.from < this.cursor.to) {
@@ -3759,8 +3760,6 @@
                        this.pointRank = this.cursor.rank;
                        this.to = this.cursor.to;
                        this.endSide = nextVal.endSide;
-                       if (this.cursor.from < from)
-                           trackExtra = 1;
                        this.cursor.next();
                        this.forward(this.to, this.endSide);
                        break;
@@ -3768,10 +3767,9 @@
                }
            }
            if (trackOpen) {
-               let openStart = 0;
-               while (openStart < trackOpen.length && trackOpen[openStart] < from)
-                   openStart++;
-               this.openStart = openStart + trackExtra;
+               this.openStart = 0;
+               for (let i = trackOpen.length - 1; i >= 0 && trackOpen[i] < from; i--)
+                   this.openStart++;
            }
        }
        activeForPoint(to) {
@@ -5826,7 +5824,7 @@
                    }
                }
                let take = Math.min(this.text.length - this.textOff, length, 512 /* T.Chunk */);
-               this.flushBuffer(active.slice(0, openStart));
+               this.flushBuffer(active.slice(active.length - openStart));
                this.getLine().append(wrapMarks(new TextView(this.text.slice(this.textOff, this.textOff + take)), active), openStart);
                this.atCursorPos = true;
                this.textOff += take;
@@ -20367,6 +20365,8 @@
            if (tr.selection || active.some(a => a.hasResult() && tr.changes.touchesRange(a.from, a.to)) ||
                !sameResults(active, this.active))
                open = CompletionDialog.build(active, state, this.id, this.open, conf);
+           else if (open && open.disabled && !active.some(a => a.state == 1 /* State.Pending */))
+               open = null;
            else if (open && tr.docChanged)
                open = open.map(tr.changes);
            if (!open && active.every(a => a.state != 1 /* State.Pending */) && active.some(a => a.hasResult()))
@@ -21292,7 +21292,7 @@
    - F8: [`nextDiagnostic`](https://codemirror.net/6/docs/ref/#lint.nextDiagnostic)
    */
    const lintKeymap = [
-       { key: "Mod-Shift-m", run: openLintPanel },
+       { key: "Mod-Shift-m", run: openLintPanel, preventDefault: true },
        { key: "F8", run: nextDiagnostic }
    ];
    const lintPlugin = /*@__PURE__*/ViewPlugin.fromClass(class {
@@ -21916,10 +21916,10 @@
        canShift(term) {
            for (let sim = new SimulatedStack(this);;) {
                let action = this.p.parser.stateSlot(sim.state, 4 /* DefaultReduce */) || this.p.parser.hasAction(sim.state, term);
-               if ((action & 65536 /* ReduceFlag */) == 0)
-                   return true;
                if (action == 0)
                    return false;
+               if ((action & 65536 /* ReduceFlag */) == 0)
+                   return true;
                sim.reduce(action);
            }
        }
@@ -23862,6 +23862,11 @@
 
    /* global google */
 
+   function unquoteSqlId (identifier) {
+     const match = identifier.match(/^`(.*)`$/);
+     return match ? match[1] : identifier
+   }
+
    function init (parent, onSubmit, onShiftSubmit) {
      addClickListener(document.getElementById('query-tab-button'), (event) => selectTab(event, 'query'));
      addClickListener(document.getElementById('saved-tab-button'), (event) => selectTab(event, 'saved'));
@@ -23956,16 +23961,17 @@
      schemas.forEach(([schemaName, schema]) => {
        Object.entries(schema.tables).forEach(([tableName, table]) => {
          const qualifiedTableName = schemas.length === 1 ? tableName : `${schemaName}.${tableName}`;
+         const quotedQualifiedTableName = schemas.length === 1 ? `\`${tableName}\`` : `\`${schemaName}\`.\`${tableName}\``;
          const columns = Object.keys(table.columns);
          editorSchema[qualifiedTableName] = columns;
-         const alias = window.metadata.table_aliases[tableName];
+         const alias = window.metadata.table_aliases[qualifiedTableName];
          if (alias) {
            editorSchema[alias] = columns;
            tables.push({
              label: qualifiedTableName,
              detail: alias,
              alias_type: 'with',
-             quoted: '`' + qualifiedTableName + '` ' + alias,
+             quoted: `${quotedQualifiedTableName} \`${alias}\``,
              unquoted: `${qualifiedTableName} ${alias}`
            });
            tables.push({
@@ -24018,40 +24024,81 @@
        schema: editorSchema,
        tables
      };
-     const scs = schemaCompletionSource(sqlConfig);
+     const originalSchemaCompletionSource = schemaCompletionSource(sqlConfig);
+     const originalKeywordCompletionSource = keywordCompletionSource(MySQL, true);
+     const keywordCompletions = [];
+     window.metadata.joins.forEach((join) => {
+       ['JOIN', 'INNER JOIN', 'LEFT JOIN', 'RIGHT JOIN', 'CROSS JOIN'].forEach((type) => {
+         keywordCompletions.push({ label: `${type} ${join.label}`, apply: `${type} ${join.apply}`, type: 'keyword' });
+       });
+     });
+     let combinedKeywordCompletionSource;
+     if (keywordCompletions.length > 0) {
+       const customKeywordCompletionSource = ifNotIn(['QuotedIdentifier', 'SpecialVar', 'String', 'LineComment', 'BlockComment', '.'], completeFromList(keywordCompletions));
+       combinedKeywordCompletionSource = function (context) {
+         const original = originalKeywordCompletionSource(context);
+         const custom = customKeywordCompletionSource(context);
+         if (original?.options && custom?.options) {
+           original.options = original.options.concat(custom.options);
+         }
+         return original
+       };
+     } else {
+       combinedKeywordCompletionSource = originalKeywordCompletionSource;
+     }
      const sqlExtension = new LanguageSupport(
        MySQL.language,
        [
          MySQL.language.data.of({
            autocomplete: (context) => {
-             const result = scs(context);
+             const result = originalSchemaCompletionSource(context);
              if (!hasTableAliases || !result?.options) return result
 
              const tree = syntaxTree(context.state);
              let node = tree.resolveInner(context.pos, -1);
+             if (!node) return result
 
              // We are trying to identify the case where we are autocompleting a table name after "from" or "join"
+
              // TODO: we don't handle the case where a user typed "select table.foo from". In that case we probably
              // shouldn't autocomplete the alias. Though, if the user typed "select table.foo, t.bar", we won't know
-             // what to do.
+             // what to do. Maybe it is ok to force users to simply delete the alias after autocompleting.
+
              // TODO: if table aliases aren't enabled, we don't need to override autocomplete.
 
-             if (node?.name === 'Statement') {
+             let foundSchema;
+             if (node.name === 'Statement') {
                // The node can be a Statement if the cursor is at the end of "from " and there is a complete
                // statement in the editor (semicolon present). In that case we want to find the node just before the
                // current position so that we can check whether it is "from" or "join".
                node = node.childBefore(context.pos);
-             } else if (node?.name === 'Script') {
+             } else if (node.name === 'Script') {
                // It seems the node can sometimes be a Script if the cursor is at the end of the last statement in the
                // editor and the statement doesn't end in a semicolon. In that case we can find the last statement in the
                // Script so that we can check whether it is "from" or "join".
                node = node.lastChild?.childBefore(context.pos);
-             } else if (['Identifier', 'QuotedIdentifier', 'Keyword'].includes(node?.name)) {
+             } else if (['Identifier', 'QuotedIdentifier', 'Keyword', '.'].includes(node.name)) {
                // If the node is an Identifier, we might be in the middle of typing the table name. If the node is a
                // Keyword but isn't "from" or "join", we might be in the middle of typing a table name that is similar
                // to a Keyword, for instance "orders" or "selections" or "fromages". In these cases, look for the previous
-               // sibling so that we can check whether it is "from" or "join".
-               node = node.prevSibling;
+               // sibling so that we can check whether it is "from" or "join". If we found a '.' or if the previous
+               // sibling is a '.', we might be in the middle of typing something like "schema.table" or
+               // "`schema`.table" or "`schema`.`table`". In these cases we need to record the schema used so that we
+               // can autocomplete table names with aliases.
+               if (node.name !== '.') {
+                 node = node.prevSibling;
+               }
+
+               if (node?.name === '.') {
+                 node = node.prevSibling;
+                 if (['Identifier', 'QuotedIdentifier'].includes(node?.name)) {
+                   foundSchema = unquoteSqlId(context.state.doc.sliceString(node.from, node.to));
+                   node = node.parent;
+                   if (node?.name === 'CompositeIdentifier') {
+                     node = node.prevSibling;
+                   }
+                 }
+               }
              }
 
              const nodeText = node ? context.state.doc.sliceString(node.from, node.to).toLowerCase() : null;
@@ -24076,13 +24123,21 @@
                    option.apply = option.unquoted;
                  }
                }
+               if (foundSchema) {
+                 const unquotedLabel = unquoteSqlId(option.label);
+                 const quoted = unquotedLabel !== option.label;
+                 const alias = window.metadata.table_aliases[`${foundSchema}.${unquotedLabel}`];
+                 if (alias) {
+                   option = { label: quoted ? `\`${unquotedLabel}\` \`${alias}\`` : `${option.label} ${alias}` };
+                 }
+               }
                return option
              });
              return result
            }
          }),
          MySQL.language.data.of({
-           autocomplete: keywordCompletionSource(MySQL, true)
+           autocomplete: combinedKeywordCompletionSource
          })
        ]
      );

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sqlui
 version: !ruby/object:Gem::Version
-  version: 0.1.40
+  version: 0.1.41
 platform: ruby
 authors:
 - Nick Dower