Flink SQL Client

import org.apache.flink.table.client.SqlClient;
import org.apache.flink.table.client.cli.CliClient;
import org.apache.flink.table.client.cli.CliOptions;
import org.apache.flink.table.client.gateway.Executor;
import org.apache.flink.table.client.gateway.local.LocalExecutor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.configuration.ReadableConfig;
import org.apache.flink.table.operations.ModifyOperation;
import org.apache.flink.types.Row;

import org.apache.flink.table.client.SqlClient;
import org.apache.flink.table.client.cli.CliOptions;
import org.apache.flink.table.client.cli.CliOptionsParser;

// Start SQL Client from command line
public class Example {
    public static void main(String[] args) {
        // Parse command line options
        CliOptions options = CliOptionsParser.parseEmbeddedModeClient(args);
        
        // Start SQL Client in embedded mode
        SqlClient.main(new String[]{"embedded", "--jar", "path/to/flink-sql-client.jar"});
    }
}

// Programmatic usage
import org.apache.flink.table.client.gateway.local.LocalExecutor;
import org.apache.flink.table.client.gateway.context.DefaultContext;
import org.apache.flink.table.client.gateway.local.LocalContextUtils;
import org.apache.flink.table.operations.Operation;
import org.apache.flink.table.operations.QueryOperation;
import org.apache.flink.table.api.TableResult;
import org.apache.flink.table.client.gateway.ResultDescriptor;

// Create executor and session
DefaultContext context = LocalContextUtils.buildDefaultContext(options);
Executor executor = new LocalExecutor(context);
executor.start();

// Open session and execute SQL
String sessionId = executor.openSession(null);
try {
    // Parse and execute SQL statements
    Operation operation = executor.parseStatement(sessionId, "CREATE TABLE MyTable (id INT, name STRING)");
    TableResult result = executor.executeOperation(sessionId, operation);
    
    // Execute queries with result retrieval
    QueryOperation query = (QueryOperation) executor.parseStatement(sessionId, "SELECT * FROM MyTable");
    ResultDescriptor resultDesc = executor.executeQuery(sessionId, query);
} finally {
    executor.closeSession(sessionId);
}

public class SqlClient {
    public static void main(String[] args);
    
    public static void startClient(String[] args, Supplier<Terminal> terminalFactory);
    
    public static final String MODE_EMBEDDED = "embedded";
    public static final String MODE_GATEWAY = "gateway";
}

public class CliClient implements AutoCloseable {
    public void executeInInteractiveMode();
    public void executeInNonInteractiveMode(String content);
    public boolean executeInitialization(String content);
    public Terminal getTerminal();
    public String getSessionId();
    public Executor getExecutor();
}

public class CliOptions {
    public boolean isPrintHelp();
    public String getSessionId();
    public URL getInitFile();
    public URL getSqlFile();
    public List<URL> getJars();
    public List<URL> getLibraryDirs();
    public String getUpdateStatement();
    public String getHistoryFilePath();
    public Configuration getPythonConfiguration();
}

public interface Executor {
    void start() throws SqlExecutionException;
    String openSession(String sessionId) throws SqlExecutionException;
    void closeSession(String sessionId) throws SqlExecutionException;
    
    Map<String, String> getSessionConfigMap(String sessionId) throws SqlExecutionException;
    ReadableConfig getSessionConfig(String sessionId) throws SqlExecutionException;
    void resetSessionProperties(String sessionId) throws SqlExecutionException;
    void resetSessionProperty(String sessionId, String key) throws SqlExecutionException;
    void setSessionProperty(String sessionId, String key, String value) throws SqlExecutionException;
    
    Operation parseStatement(String sessionId, String statement) throws SqlExecutionException;
    List<String> completeStatement(String sessionId, String statement, int position);
    TableResult executeOperation(String sessionId, Operation operation) throws SqlExecutionException;
    TableResult executeModifyOperations(String sessionId, List<ModifyOperation> operations) throws SqlExecutionException;
    ResultDescriptor executeQuery(String sessionId, QueryOperation query) throws SqlExecutionException;
    
    TypedResult<List<Row>> retrieveResultChanges(String sessionId, String resultId) throws SqlExecutionException;
    TypedResult<Integer> snapshotResult(String sessionId, String resultId, int pageSize) throws SqlExecutionException;
    List<Row> retrieveResultPage(String resultId, int page) throws SqlExecutionException;
    void cancelQuery(String sessionId, String resultId) throws SqlExecutionException;
    
    void addJar(String sessionId, String jarPath);
    void removeJar(String sessionId, String jarPath);
    List<String> listJars(String sessionId);
}

public class LocalExecutor implements Executor {
    public LocalExecutor(DefaultContext defaultContext);
}

public class DefaultContext {
    public Configuration getFlinkConfig();
    public List<URL> getDependencies();
}

public class SessionContext {
    public String getSessionId();
    public Map<String, String> getConfigMap();
    public ReadableConfig getReadableConfig();
    public void set(String key, String value);
    public void reset();
    public void reset(String key);
    public void addJar(String jarUrl);
    public void removeJar(String jarUrl);
    public List<String> listJars();
    public void close();
}

public class ResultDescriptor {
    public String getResultId();
    public ResolvedSchema getResultSchema();
    public boolean isMaterialized();
    public boolean isTableauMode();
    public boolean isStreamingMode();
}

public class TypedResult<P> {
    public ResultType getType();
    public P getPayload();
    
    public static <T> TypedResult<T> empty();
    public static <T> TypedResult<T> payload(T payload);
    public static <T> TypedResult<T> endOfStream();
}

public enum ResultType {
    PAYLOAD, EMPTY, EOS
}

public class SqlClientOptions {
    public static final ConfigOption<Integer> EXECUTION_MAX_TABLE_RESULT_ROWS;
    public static final ConfigOption<ResultMode> EXECUTION_RESULT_MODE;
    public static final ConfigOption<Boolean> VERBOSE;
    public static final ConfigOption<Integer> DISPLAY_MAX_COLUMN_WIDTH;
}

public enum ResultMode {
    TABLE, CHANGELOG, TABLEAU
}

public class SqlClientException extends RuntimeException {
    public SqlClientException(String message);
    public SqlClientException(String message, Throwable cause);
    public SqlClientException(Throwable cause);
}

public class SqlExecutionException extends Exception {
    public SqlExecutionException(String message);
    public SqlExecutionException(String message, Throwable cause);
}

public class LocalContextUtils {
    public static DefaultContext buildDefaultContext(CliOptions options);
    public static SessionContext buildSessionContext(String sessionId, DefaultContext defaultContext);
}

public class CliOptionsParser {
    public static CliOptions parseEmbeddedModeClient(String[] args);
    public static void printHelpEmbeddedModeClient();
}

public class TerminalUtils {
    public static Terminal createDefaultTerminal();
    public static Terminal createDumbTerminal(OutputStream outputStream);
}