yb_ddl_parser 0.1.0

data/ext/yb_ddl_parser/yb_parser_stubs.c

@@ -0,0 +1,459 @@
+#include "ruby.h"
+#include "postgres.h"
+#include "catalog/pg_type_d.h"
+#include "commands/defrem.h"
+#include "mb/pg_wchar.h"
+#include "nodes/nodeFuncs.h"
+#include "nodes/parsenodes.h"
+#include "nodes/value.h"
+#include "utils/lsyscache.h"
+#include "yb/yql/pggate/ybc_gflags.h"
+
+#include <stdarg.h>
+
+bool IsBinaryUpgrade = false;
+bool IsYsqlUpgrade = false;
+MemoryContext YbCurrentMemoryContext = (MemoryContext) 0x1;
+ErrorContextCallback *error_context_stack = NULL;
+sigjmp_buf *PG_exception_stack = NULL;
+int pg_database_encoding_max_length_value = 1;
+
+static int yb_last_errcode = ERRCODE_SUCCESSFUL_COMPLETION;
+static int yb_current_elevel = LOG;
+static int yb_error_position = 0;
+static char yb_error_message[1024];
+
+static bool yb_true = true;
+static bool yb_false = false;
+
+static const YbcGFlags yb_gflags = {
+  &yb_true,
+  &yb_false,
+  &yb_true,
+  &yb_true,
+};
+
+const YbcGFlags *
+YBCGetGFlags(void)
+{
+  return &yb_gflags;
+}
+
+bool
+IsYugaByteEnabled(void)
+{
+  return true;
+}
+
+bool
+YBIsUsingYBParser(void)
+{
+  return true;
+}
+
+bool
+YbIsConnectedToTemplateDb(void)
+{
+  return false;
+}
+
+bool
+YBIsCollationEnabled(void)
+{
+  return true;
+}
+
+int
+YBUnsupportedFeatureSignalLevel(void)
+{
+  return ERROR;
+}
+
+bool
+YBCIsEnvVarTrue(const char *flag)
+{
+  return false;
+}
+
+bool
+YBCIsEnvVarTrueWithDefault(const char *flag, bool default_value)
+{
+  return default_value;
+}
+
+MemoryContext
+GetThreadLocalCurrentMemoryContext(void)
+{
+  return YbCurrentMemoryContext;
+}
+
+MemoryContext
+SetThreadLocalCurrentMemoryContext(MemoryContext memctx)
+{
+  MemoryContext old = YbCurrentMemoryContext;
+  YbCurrentMemoryContext = memctx;
+  return old;
+}
+
+static void *
+yb_alloc(Size size, bool zero)
+{
+  Size total = size + sizeof(MemoryContext);
+  char *base = zero ? calloc(1, total) : malloc(total);
+  if (base == NULL)
+    rb_memerror();
+  *((MemoryContext *) base) = YbCurrentMemoryContext;
+  return base + sizeof(MemoryContext);
+}
+
+void *
+MemoryContextAlloc(MemoryContext context, Size size)
+{
+  return yb_alloc(size, false);
+}
+
+void *
+MemoryContextAllocZero(MemoryContext context, Size size)
+{
+  return yb_alloc(size, true);
+}
+
+void *
+MemoryContextAllocZeroAligned(MemoryContext context, Size size)
+{
+  return yb_alloc(size, true);
+}
+
+void *
+MemoryContextAllocExtended(MemoryContext context, Size size, int flags)
+{
+  return yb_alloc(size, (flags & MCXT_ALLOC_ZERO) != 0);
+}
+
+void *
+palloc(Size size)
+{
+  return MemoryContextAlloc(CurrentMemoryContext, size);
+}
+
+void *
+palloc0(Size size)
+{
+  return MemoryContextAllocZero(CurrentMemoryContext, size);
+}
+
+void *
+palloc_extended(Size size, int flags)
+{
+  return MemoryContextAllocExtended(CurrentMemoryContext, size, flags);
+}
+
+void *
+repalloc(void *pointer, Size size)
+{
+  if (pointer == NULL)
+    return palloc(size);
+
+  char *old_base = ((char *) pointer) - sizeof(MemoryContext);
+  char *new_base = realloc(old_base, size + sizeof(MemoryContext));
+  if (new_base == NULL)
+    rb_memerror();
+  return new_base + sizeof(MemoryContext);
+}
+
+void
+pfree(void *pointer)
+{
+  if (pointer != NULL)
+    free(((char *) pointer) - sizeof(MemoryContext));
+}
+
+char *
+pstrdup(const char *in)
+{
+  Size len = strlen(in) + 1;
+  char *out = palloc(len);
+  memcpy(out, in, len);
+  return out;
+}
+
+char *
+psprintf(const char *fmt, ...)
+{
+  va_list args;
+  va_list args_copy;
+  va_start(args, fmt);
+  va_copy(args_copy, args);
+  int len = vsnprintf(NULL, 0, fmt, args);
+  va_end(args);
+  if (len < 0)
+    rb_raise(rb_eRuntimeError, "vsnprintf failed");
+  char *out = palloc((Size) len + 1);
+  vsnprintf(out, (Size) len + 1, fmt, args_copy);
+  va_end(args_copy);
+  return out;
+}
+
+void
+YBCLogImpl(int severity, const char *file_name, int line_number, bool stack_trace,
+           const char *format, ...)
+{
+}
+
+void
+YBCLogVA(int severity, const char *file_name, int line_number, bool stack_trace,
+         const char *format, va_list args)
+{
+}
+
+const char *
+YBCGetStackTrace(void)
+{
+  return "";
+}
+
+bool
+YBCIsInitDbModeEnvVarSet(void)
+{
+  return false;
+}
+
+bool
+YBIsMajorUpgradeInitDb(void)
+{
+  return false;
+}
+
+bool
+YBCIsObjectLockingEnabled(void)
+{
+  return false;
+}
+
+bool
+message_level_is_interesting(int elevel)
+{
+  return elevel >= ERROR;
+}
+
+bool
+errstart(int elevel, const char *domain)
+{
+  yb_current_elevel = elevel;
+  if (elevel >= ERROR)
+  {
+    yb_error_position = 0;
+    yb_error_message[0] = '\0';
+  }
+  return true;
+}
+
+bool
+errstart_cold(int elevel, const char *domain)
+{
+  return errstart(elevel, domain);
+}
+
+void
+errfinish(const char *filename, int lineno, const char *funcname)
+{
+  if (yb_current_elevel >= ERROR)
+  {
+    if (PG_exception_stack != NULL)
+      siglongjmp(*PG_exception_stack, 1);
+
+    rb_raise(rb_eRuntimeError, "%s", yb_error_message[0] ? yb_error_message : "parser error");
+  }
+}
+
+int
+errcode(int sqlerrcode)
+{
+  yb_last_errcode = sqlerrcode;
+  return 0;
+}
+
+static void
+yb_set_error_message(const char *fmt, va_list args)
+{
+  vsnprintf(yb_error_message, sizeof(yb_error_message), fmt, args);
+}
+
+int
+errmsg(const char *fmt, ...)
+{
+  va_list args;
+  va_start(args, fmt);
+  yb_set_error_message(fmt, args);
+  va_end(args);
+  return 0;
+}
+
+int
+errmsg_internal(const char *fmt, ...)
+{
+  va_list args;
+  va_start(args, fmt);
+  yb_set_error_message(fmt, args);
+  va_end(args);
+  return 0;
+}
+int errdetail(const char *fmt, ...) { return 0; }
+int errhint(const char *fmt, ...) { return 0; }
+int
+errposition(int cursorpos)
+{
+  yb_error_position = cursorpos;
+  return 0;
+}
+
+int
+geterrcode(void)
+{
+  return yb_last_errcode;
+}
+
+bool yb_errstart(int elevel) { return errstart(elevel, NULL); }
+bool yb_errstart_cold(int elevel) { return errstart(elevel, NULL); }
+void yb_errfinish(const char *filename, int lineno, const char *funcname) {}
+sigjmp_buf *yb_get_exception_stack(void) { return PG_exception_stack; }
+void yb_set_exception_stack(sigjmp_buf *new_sigjmp_buf) { PG_exception_stack = new_sigjmp_buf; }
+void yb_reset_error_status(void) {}
+
+const char *
+yb_parser_last_error_message(void)
+{
+  return yb_error_message[0] ? yb_error_message : "parser error";
+}
+
+int
+yb_parser_last_error_position(void)
+{
+  return yb_error_position;
+}
+
+int
+pg_database_encoding_max_length(void)
+{
+  return pg_database_encoding_max_length_value;
+}
+
+int
+pg_get_client_encoding(void)
+{
+  return PG_SQL_ASCII;
+}
+
+int
+pg_mbstrlen_with_len(const char *mbstr, int len)
+{
+  return len;
+}
+
+int
+pg_mbcliplen(const char *mbstr, int len, int limit)
+{
+  return len < limit ? len : limit;
+}
+
+bool
+pg_verifymbstr(const char *mbstr, int len, bool noError)
+{
+  return true;
+}
+
+void
+pg_unicode_to_server(pg_wchar c, unsigned char *s)
+{
+  if (c <= 0x7f)
+  {
+    s[0] = (unsigned char) c;
+    s[1] = '\0';
+  }
+  else
+  {
+    s[0] = '?';
+    s[1] = '\0';
+  }
+}
+
+int
+strtoint(const char *str, char **endptr, int base)
+{
+  long value = strtol(str, endptr, base);
+  return (int) value;
+}
+
+#undef qsort
+void
+pg_qsort(void *base, size_t nel, size_t elsize,
+         int (*cmp)(const void *, const void *))
+{
+  qsort(base, nel, elsize, cmp);
+}
+
+void *
+copyObjectImpl(const void *obj)
+{
+  return (void *) obj;
+}
+
+bool
+equal(const void *a, const void *b)
+{
+  return a == b;
+}
+
+Oid exprType(const Node *expr) { return InvalidOid; }
+int32 exprTypmod(const Node *expr) { return -1; }
+Oid exprCollation(const Node *expr) { return InvalidOid; }
+int exprLocation(const Node *expr) { return -1; }
+
+char *get_rel_name(Oid relid) { return NULL; }
+Oid get_rel_type_id(Oid relid) { return InvalidOid; }
+bool type_is_rowtype(Oid typid) { return false; }
+
+void
+get_typlenbyval(Oid typid, int16 *typlen, bool *typbyval)
+{
+  *typlen = -1;
+  *typbyval = false;
+}
+
+int32
+defGetInt32(DefElem *def)
+{
+  if (def != NULL && def->arg != NULL && IsA(def->arg, Integer))
+    return intVal(def->arg);
+  return 0;
+}
+
+char *
+NameListToString(List *names)
+{
+  Size len = 1;
+  ListCell *cell;
+
+  foreach(cell, names)
+  {
+    len += strlen(strVal(lfirst(cell))) + 1;
+  }
+
+  char *out = palloc(len);
+  out[0] = '\0';
+
+  foreach(cell, names)
+  {
+    if (cell != list_head(names))
+      strcat(out, ".");
+    strcat(out, strVal(lfirst(cell)));
+  }
+
+  return out;
+}
+
+struct varlena *
+pg_detoast_datum(struct varlena *datum)
+{
+  return datum;
+}

data/lib/yb_ddl_parser/ast.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+module YbDDLParser
+  module AST
+    RelationName = Data.define(:schema, :name) do
+      def qualified_name
+        schema && !schema.empty? ? "#{schema}.#{name}" : name
+      end
+    end
+
+    KeyColumn = Data.define(:name, :expression, :order, :nulls, :hashed, :hash_group) do
+      def hash?
+        hashed == true
+      end
+    end
+
+    Constraint = Data.define(:type, :name, :columns, :key_columns, :raw_expression, :functions)
+
+    Column = Data.define(:name, :type, :typmods, :constraints)
+
+    Command = Data.define(:kind, :column, :definition, :constraint, :tablespace, :missing_ok)
+
+    TabletSplit = Data.define(:type, :num_tablets, :points)
+
+    PartitionSpec = Data.define(:strategy, :keys)
+
+    ParseDiagnostic = Data.define(:message, :position)
+
+    Statement = Data.define(
+      :kind,
+      :raw_node_type,
+      :sql,
+      :location,
+      :relation,
+      :object_type,
+      :objects,
+      :columns,
+      :constraints,
+      :primary_key,
+      :commands,
+      :index_name,
+      :unique,
+      :concurrently,
+      :access_method,
+      :keys,
+      :include_columns,
+      :where_sql,
+      :tablespace,
+      :tablet_split,
+      :partition_spec,
+      :partition_of,
+      :partition_bound_sql,
+      :if_exists,
+      :if_not_exists,
+      :name,
+      :owner,
+      :new_name,
+      :tablespace_location,
+      :replica_placement_json,
+    ) do
+      def create_table?
+        kind == :create_table
+      end
+
+      def create_index?
+        kind == :create_index
+      end
+
+      def drop_table?
+        kind == :drop && object_type == :table
+      end
+
+      def drop_index?
+        kind == :drop && object_type == :index
+      end
+
+      def alter_index?
+        kind == :alter_index
+      end
+
+      def partition_parent?
+        create_table? && !partition_spec.nil? && !partition_child?
+      end
+
+      def partition_child?
+        !partition_of.nil?
+      end
+
+      def explicit_concurrently?
+        concurrently == :explicit
+      end
+
+      def target_relations
+        return objects unless objects.empty?
+        return [relation] if relation
+
+        []
+      end
+
+      def target_relation
+        target_relations.first
+      end
+
+      def target_name
+        index_name || target_relation&.qualified_name || name
+      end
+
+      def hash_key_groups
+        groups = keys.each_with_object({}) do |key, grouped|
+          next if key.hash_group.nil?
+
+          grouped[key.hash_group] ||= []
+          grouped[key.hash_group] << (key.name || key.expression)
+        end
+
+        groups.keys.sort.map { |group| groups.fetch(group) }
+      end
+
+      def split
+        tablet_split
+      end
+
+      def partition
+        partition_spec
+      end
+    end
+
+    ParseResult = Data.define(:statements, :errors) do
+      def self.from_hash(hash)
+        new(
+          statements: Array(hash[:statements]).map { |stmt| build_statement(stmt) },
+          errors: Array(hash[:errors]).map { |error| diagnostic(error) },
+        )
+      end
+
+      def single_statement!
+        if statements.length != 1
+          raise ParseError, "expected exactly one statement, got #{statements.length}"
+        end
+
+        statements.first
+      end
+
+      def each_statement(&block)
+        statements.each(&block)
+      end
+
+      def each_column
+        return enum_for(:each_column) unless block_given?
+
+        statements.each do |stmt|
+          stmt.columns.each { |column| yield column, stmt } if stmt.columns
+          stmt.commands.each do |cmd|
+            yield cmd.column, stmt if cmd.column
+          end if stmt.commands
+        end
+      end
+
+      def self.build_statement(hash)
+        Statement.new(
+          kind: sym(hash[:kind]),
+          raw_node_type: hash[:raw_node_type],
+          sql: hash[:sql],
+          location: hash[:location],
+          relation: relation(hash[:relation]),
+          object_type: sym(hash[:object_type]),
+          objects: Array(hash[:objects]).map { |obj| relation(obj) },
+          columns: Array(hash[:columns]).map { |col| column(col) },
+          constraints: Array(hash[:constraints]).map { |constraint_hash| constraint(constraint_hash) },
+          primary_key: hash[:primary_key] && constraint(hash[:primary_key]),
+          commands: Array(hash[:commands]).map { |cmd| command(cmd) },
+          index_name: hash[:index_name],
+          unique: hash[:unique],
+          concurrently: sym(hash[:concurrently]),
+          access_method: hash[:access_method],
+          keys: Array(hash[:keys]).map { |key| key_column(key) },
+          include_columns: Array(hash[:include_columns]),
+          where_sql: hash[:where_sql],
+          tablespace: hash[:tablespace],
+          tablet_split: tablet_split(hash[:split]),
+          partition_spec: partition_spec(hash[:partition]),
+          partition_of: relation(hash[:partition_of]),
+          partition_bound_sql: hash[:partition_bound_sql],
+          if_exists: hash[:if_exists],
+          if_not_exists: hash[:if_not_exists],
+          name: hash[:name],
+          owner: hash[:owner],
+          new_name: hash[:new_name],
+          tablespace_location: hash[:tablespace_location],
+          replica_placement_json: hash[:replica_placement_json],
+        )
+      end
+
+      def self.diagnostic(hash)
+        ParseDiagnostic.new(
+          message: hash[:message],
+          position: hash[:position],
+        )
+      end
+
+      def self.tablet_split(hash)
+        return unless hash
+
+        TabletSplit.new(
+          type: sym(hash[:type]),
+          num_tablets: hash[:num_tablets],
+          points: hash[:points],
+        )
+      end
+
+      def self.partition_spec(hash)
+        return unless hash
+
+        PartitionSpec.new(
+          strategy: sym(hash[:strategy]),
+          keys: Array(hash[:keys]),
+        )
+      end
+
+      def self.command(hash)
+        Command.new(
+          kind: sym(hash[:kind]),
+          column: hash[:column] && column(hash[:column]),
+          definition: hash[:definition],
+          constraint: hash[:constraint] && constraint(hash[:constraint]),
+          tablespace: hash[:tablespace],
+          missing_ok: hash[:missing_ok],
+        )
+      end
+
+      def self.column(hash)
+        Column.new(
+          name: hash[:name],
+          type: hash[:type],
+          typmods: Array(hash[:typmods]),
+          constraints: Array(hash[:constraints]).map { |constraint_hash| constraint(constraint_hash) },
+        )
+      end
+
+      def self.constraint(hash)
+        Constraint.new(
+          type: sym(hash[:type]),
+          name: hash[:name],
+          columns: Array(hash[:columns]),
+          key_columns: Array(hash[:key_columns]).map { |key| key_column(key) },
+          raw_expression: hash[:raw_expression],
+          functions: Array(hash[:functions]),
+        )
+      end
+
+      def self.key_column(hash)
+        KeyColumn.new(
+          name: hash[:name],
+          expression: hash[:expression],
+          order: sym(hash[:order]),
+          nulls: sym(hash[:nulls]),
+          hashed: hash[:hash],
+          hash_group: hash[:hash_group],
+        )
+      end
+
+      def self.relation(hash)
+        return unless hash
+
+        RelationName.new(schema: hash[:schema], name: hash[:name])
+      end
+
+      def self.sym(value)
+        value.nil? ? nil : value.to_sym
+      end
+    end
+  end
+
+  Statement = AST::Statement
+  ParseResult = AST::ParseResult
+end

data/lib/yb_ddl_parser/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module YbDDLParser
+  VERSION = File.read(File.expand_path("../../VERSION", __dir__)).strip
+end
+