void createTable(Table tbl) throws AlreadyExistsException, InvalidObjectException, MetaException, NoSuchObjectException, TException;

if (localMetaStore) {

  if (!allowEmbedded) {

    throw new MetaException("Embedded metastore is not allowed here. Please configure "

        + ConfVars.THRIFT_URIS.toString() + "; it is currently set to [" + msUri + "]");

  }

  client = callEmbeddedMetastore(this.conf);

  // instantiate the metastore server handler directly instead of connecting

  // through the network

  isConnected = true;

  snapshotActiveConf();

  return;

}

open();

@Override

public void createTable(CreateTableRequest request) throws

        InvalidObjectException, MetaException, NoSuchObjectException, TException {

  Table tbl = request.getTable();

  if (!tbl.isSetCatName()) {

    tbl.setCatName(getDefaultCatalog(conf));

  }

  if (processorCapabilities != null) {

    request.setProcessorCapabilities(new ArrayList<String>(Arrays.asList(processorCapabilities)));

    request.setProcessorIdentifier(processorIdentifier);

  }

  HiveMetaHook hook = getHook(tbl);

  if (hook != null) {

    hook.preCreateTable(tbl);

  }

  boolean success = false;

  try {

    // Subclasses can override this step (for example, for temporary tables)

    if (hook == null || !hook.createHMSTableInHook()) {

      create_table(request);

    }

    if (hook != null) {

      hook.commitCreateTable(tbl);

    }

    success = true;

  } finally {

    if (!success && (hook != null)) {

      try {

        hook.rollbackCreateTable(tbl);

      } catch (Exception e) {

        LOG.error("Create rollback failed with", e);

      }

    }

  }

}

protected void create_table(CreateTableRequest request) throws

    InvalidObjectException, MetaException, NoSuchObjectException, TException {

  client.create_table_req(request);

}

public static void main(String[] args) throws Throwable {

  ...

  startMetaStore(cli.getPort(), HadoopThriftAuthBridge.getBridge(), conf, true, null);

  ...

}

public static void startMetaStore(int port, HadoopThriftAuthBridge bridge,

    Configuration conf, boolean startMetaStoreThreads, AtomicBoolean startedBackgroundThreads) throws Throwable {

  isMetaStoreRemote = true;

  String transportMode = MetastoreConf.getVar(conf, ConfVars.THRIFT_TRANSPORT_MODE, "binary");

  boolean isHttpTransport = transportMode.equalsIgnoreCase("http");

  if (isHttpTransport) {

    thriftServer = startHttpMetastore(port, conf);

  } else {

    thriftServer = startBinaryMetastore(port, bridge, conf);

  }

  logCompactionParameters(conf);

  boolean directSqlEnabled = MetastoreConf.getBoolVar(conf, ConfVars.TRY_DIRECT_SQL);

  LOG.info("Direct SQL optimization = {}",  directSqlEnabled);

  if (startMetaStoreThreads) {

    Lock metaStoreThreadsLock = new ReentrantLock();

    Condition startCondition = metaStoreThreadsLock.newCondition();

    AtomicBoolean startedServing = new AtomicBoolean();

    startMetaStoreThreads(conf, metaStoreThreadsLock, startCondition, startedServing,

        isMetaStoreHousekeepingLeader(conf), startedBackgroundThreads);

    signalOtherThreadsToStart(thriftServer, metaStoreThreadsLock, startCondition, startedServing);

  }

  // If dynamic service discovery through ZooKeeper is enabled, add this server to the ZooKeeper.

  if (MetastoreConf.getVar(conf, ConfVars.THRIFT_SERVICE_DISCOVERY_MODE)

          .equalsIgnoreCase("zookeeper")) {

    try {

      zooKeeperHelper = MetastoreConf.getZKConfig(conf);

      String serverInstanceURI = getServerInstanceURI(port);

      zooKeeperHelper.addServerInstanceToZooKeeper(serverInstanceURI, serverInstanceURI, null,

          new ZKDeRegisterWatcher(zooKeeperHelper));

      LOG.info("Metastore server instance with URL " + serverInstanceURI + " added to " +

          "the zookeeper");

    } catch (Exception e) {

      LOG.error("Error adding this metastore instance to ZooKeeper: ", e);

      throw e;

    }

  }

  thriftServer.start();

}

private static ThriftServer startBinaryMetastore(int port, HadoopThriftAuthBridge bridge,

    Configuration conf) throws Throwable {

  ...

  TProcessor processor;

  ...

  IHMSHandler handler = newRetryingHMSHandler(baseHandler, conf);

  TServerSocket serverSocket;

  if (useSasl) {

    processor = saslServer.wrapProcessor(

        new ThriftHiveMetastore.Processor<>(handler));

    LOG.info("Starting DB backed MetaStore Server in Secure Mode");

  } else {

    // we are in unsecure mode.

    if (MetastoreConf.getBoolVar(conf, ConfVars.EXECUTE_SET_UGI)) {

      processor = new TUGIBasedProcessor<>(handler);

      LOG.info("Starting DB backed MetaStore Server with SetUGI enabled");

    } else {

      processor = new TSetIpAddressProcessor<>(handler);

      LOG.info("Starting DB backed MetaStore Server");

    }

  }

  ...

  TThreadPoolServer.Args args = new TThreadPoolServer.Args(serverSocket)

      .processor(processor)

      .transportFactory(transFactory)

      .protocolFactory(protocolFactory)

      .inputProtocolFactory(inputProtoFactory)

      .executorService(executorService);

  TServer tServer = new TThreadPoolServer(args);

  ...

}

@Override

public void create_table_req(final CreateTableRequest req)

    throws AlreadyExistsException, MetaException, InvalidObjectException,

    InvalidInputException {

  Table tbl = req.getTable();

  startFunction("create_table_req", ": " + tbl.toString());

  boolean success = false;

  Exception ex = null;

  try {

    create_table_core(getMS(), req);

    success = true;

  } catch (Exception e) {

    LOG.warn("create_table_req got ", e);

    ex = e;

    throw handleException(e).throwIfInstance(MetaException.class, InvalidObjectException.class)

        .throwIfInstance(AlreadyExistsException.class, InvalidInputException.class)

        .convertIfInstance(NoSuchObjectException.class, InvalidObjectException.class)

        .defaultMetaException();

  } finally {

    endFunction("create_table_req", success, ex, tbl.getTableName());

  }

}

void createTable(Table tbl) throws InvalidObjectException, MetaException;

private void create_table_core(final RawStore ms, final CreateTableRequest req)

    throws AlreadyExistsException, MetaException,

    InvalidObjectException, NoSuchObjectException, InvalidInputException {

  ms.openTransaction();

  firePreEvent(new PreCreateTableEvent(tbl, db, this));

  try {

    wh.mkdirs(tblPath);

    ms.createTable(tbl);

    success = ms.commitTransaction();

  } finally {

    if (!success) {

      ms.rollbackTransaction();

    }

    if (!listeners.isEmpty()) {

      MetaStoreListenerNotifier.notifyEvent(listeners, EventType.CREATE_TABLE,

          new CreateTableEvent(tbl, success, this, isReplicated), envContext,

          transactionalListenerResponses, ms);

      if (CollectionUtils.isNotEmpty(constraints.getPrimaryKeys())) {

        MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ADD_PRIMARYKEY,

            new AddPrimaryKeyEvent(constraints.getPrimaryKeys(), success, this), envContext);

      }

      if (CollectionUtils.isNotEmpty(constraints.getForeignKeys())) {

        MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ADD_FOREIGNKEY,

            new AddForeignKeyEvent(constraints.getForeignKeys(), success, this), envContext);

      }

      if (CollectionUtils.isNotEmpty(constraints.getUniqueConstraints())) {

        MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ADD_UNIQUECONSTRAINT,

            new AddUniqueConstraintEvent(constraints.getUniqueConstraints(), success, this), envContext);

      }

      if (CollectionUtils.isNotEmpty(constraints.getNotNullConstraints())) {

        MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ADD_NOTNULLCONSTRAINT,

            new AddNotNullConstraintEvent(constraints.getNotNullConstraints(), success, this), envContext);

      }

      if (CollectionUtils.isNotEmpty(constraints.getDefaultConstraints())) {

        MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ADD_DEFAULTCONSTRAINT,

            new AddDefaultConstraintEvent(constraints.getDefaultConstraints(), success, this), envContext);

      }

      if (CollectionUtils.isNotEmpty(constraints.getCheckConstraints())) {

        MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ADD_CHECKCONSTRAINT,

            new AddCheckConstraintEvent(constraints.getCheckConstraints(), success, this), envContext);

      }

    }

  }

}