FAQ

How do I access OSS across accounts?

By default, EMR Serverless StarRocks provides password-free access to OSS buckets in the same account. To access OSS resources in another account, you must disable this default, configure the target account's AccessKey pair, and apply the new configuration.

1. Disable password-free access: On the Parameter Configuration tab, clear the values of the following configuration items in the specified files.

   • core-site.xml

     fs.oss.credentials.provider =

   • jindosdk.cfg

     fs.oss.provider.format =
     fs.oss.provider.endpoint =

2. Add the AccessKey pair for the target account: On the Parameter Configuration tab, click Add Configuration Item and add the following configurations to the specified files.

   • core-site.xml

     fs.oss.accessKeyId = AccessKey ID of the target account
     fs.oss.accessKeySecret = AccessKey Secret of the target account

   • jindosdk.cfg

     fs.oss.accessKeyId = AccessKey ID of the target account
     fs.oss.accessKeySecret = AccessKey Secret of the target account

3. Apply the configuration: On the Parameter Configuration tab, click Submit Parameters.

Use UDF and JDBC connector drivers

Before you use UDF and JDBC drivers, you must obtain the required JAR files from an external source.

1. Upload the JAR files to OSS. For more information, see Upload files.

   When you upload the files, set the object ACL to Public Read/Write to grant the JAR files public read and write permissions.

2. Obtain the URL for each JAR file.

   In the OSS console, find the link for each successfully uploaded JAR file. Use the HTTP URL of the internal endpoint, which must be in one of the following formats:

   • For a JDBC driver: http://<YourBucketName>.oss-cn-xxxx-internal.aliyuncs.com/mysql-connector-java-*.jar.

   • For a UDF: http://<YourBucketName>.oss-cn-xxxx-internal.aliyuncs.com/<YourPath>/<jar_package_name>.

3. Use the JAR files. For more information, see Java UDF and JDBC Catalog.

How do I reset the instance password?

1. Go to the instance details page.

   1. Log in to the E-MapReduce console.

   2. In the left-side navigation pane, choose EMR Serverless > StarRocks.

   3. Click the name of the target instance.

2. On the Instance Details page, in the Basic Information section, click Reset Password.

3. In the dialog box that appears, enter and confirm the new password, and then click OK.

Error writing data to Paimon tables

• Symptom: When you use StarRocks to write data to a Paimon table, you may receive the following error message:

  (5025, 'Backend node not found. Check if any backend node is down.')

• Cause: A permission check in Paimon tables can prevent StarRocks from correctly identifying BE nodes during write operations.

• Solution:

  • Upgrade the version (Recommended): If your instance version is earlier than one of the following, perform a minor version update to apply the fix.

    • StarRocks 3.2: 3.2.11-1.89 or later

    • StarRocks 3.3: 3.3.8-1.88 or later

  • Workaround: On the Parameter Configuration tab of the StarRocks instance, add the following configuration item to the core-site.xml file.

    dlf.permission.clientCheck=false

When creating a foreign table in StarRocks, if you receive the not a RAM user error, what should you do?

• Symptom: When creating a foreign table in StarRocks, you may receive the following error message:

  current user is not a RAM user

• Cause: This error is caused by insufficient permissions or an outdated instance version.

• Solution:

  1. Check the RAM user permissions: Ensure that the Resource Access Management (RAM) user has the required permissions for StarRocks. For more information, see Grant permissions to a RAM user.

  2. If the permissions are correct, check and upgrade the kernel version on the StarRocks Instance Details page.

     If your instance version is earlier than one of the following, perform a minor version update to apply the fix.

     • StarRocks 3.2: 3.2.11-1.89 or later

     • StarRocks 3.3: 3.3.8-1.88 or later

Error with semicolons in the SQL Editor

• Symptom: When you run an SQL statement containing a semicolon (;) in the SQL Editor, you receive an error. The error message includes the most similar input is {a legal identifier}.

  The error code is 1064, and the details also include Unexpected input '<EOF>', indicating a syntax error at line 3, column 11.

• This error occurs because the SQL Editor uses the semicolon (;) as a statement terminator by default. If your SQL statement contains a semicolon (;), a syntax parsing error occurs.

• Solution:

  1. Set a custom delimiter.

     Before you run an SQL statement that contains a semicolon, set a custom delimiter to prevent syntax parsing errors. For example, you can change the delimiter to $$.

     delimiter $$

  2. Run the SQL statement that contains a semicolon. An example is shown below:

     INSERT INTO sr_test VALUES 
     (1, 'asdsd,asdsads'), 
     (2, 'sadsad;asdsads');

  3. Restore the default delimiter.

     After the SQL statement is executed, restore the default delimiter (;) so that subsequent SQL operations can run as expected.

     delimiter ;

  4. Verify the result.

     Run a query to verify that the data was inserted correctly.

     delimiter ;
     SELECT * FROM sr_test;

     Output
       test_id    test_desc
     0       1    asdsd,asdsads
     1       2    sadsad;asdsads

Failure to import data or access foreign tables

• Symptom: When you use EMR Serverless StarRocks to import data or access a foreign table, the import or connection may fail if the destination is a public IP address.

• Cause: An EMR Serverless StarRocks instance runs in a Virtual Private Cloud (VPC) environment by default, which may not have direct access to the internet. Therefore, requests to public resources, such as for data imports or foreign table queries, fail unless internet access is configured.

• Solution: You can deploy an Internet NAT gateway in the VPC and enable the SNAT feature. This allows the EMR Serverless StarRocks instance to access public resources through the gateway. For more information, see Use the SNAT feature of an Internet NAT gateway to access the Internet.

Prevent connection closure by SLB/CLB idle timeout

• Symptom: When using SLB with a StarRocks instance, the SLB forcibly closes the client connection if an SQL query runs for more than 900 seconds, preventing the query from returning a result. For more information about enabling SLB, see Manage gateways.

• Cause: SLB closes any TCP connection that is idle for more than 900 seconds. This can happen during a long-running SQL query, interrupting the connection before StarRocks returns a result.

• Solution: Configure client-side TCP Keepalive parameters to prevent the SLB from closing idle connections.

  • Global kernel parameter settings (system-level)

    Modify the operating system's kernel parameters to enable and configure appropriate TCP Keepalive settings for all TCP connections. This helps monitor the status of network connections. The following table describes the parameters to be configured.

    Parameter	Description	Recommended value
    Linux: net.ipv4.tcp_keepalive_time FreeBSD/macOS: net.inet.tcp.keepidle	The period of inactivity in seconds after which the first Keepalive probe is sent.	600 seconds
    Linux: net.ipv4.tcp_keepalive_intvl FreeBSD/macOS: net.inet.tcp.keepintvl	The interval in seconds between Keepalive probe retransmissions.	60 seconds
    Linux: net.ipv4.tcp_keepalive_probes FreeBSD/macOS: net.inet.tcp.keepcnt	The number of consecutive failed probes after which the connection is dropped.	5

    Linux

    • Apply settings temporarily

      # Set global Keepalive parameters (root permissions required)
      sudo sysctl -w net.ipv4.tcp_keepalive_time=600   # Corresponds to keepidle (600 seconds)
      sudo sysctl -w net.ipv4.tcp_keepalive_intvl=60   # Corresponds to keepintvl (60 seconds)
      sudo sysctl -w net.ipv4.tcp_keepalive_probes=5   # Corresponds to keepcount (5)

    • Apply settings permanently

      Add the following content to /etc/sysctl.conf and run sysctl -p to apply the settings.

      echo "net.ipv4.tcp_keepalive_time = 600" >> /etc/sysctl.conf
      echo "net.ipv4.tcp_keepalive_intvl = 60" >> /etc/sysctl.conf
      echo "net.ipv4.tcp_keepalive_probes = 5" >> /etc/sysctl.conf

    FreeBSD/macOS

    • Apply settings temporarily

      # Set global Keepalive parameters (root permissions required)
      sudo sysctl -w net.inet.tcp.keepidle=600
      sudo sysctl -w net.inet.tcp.keepintvl=60
      sudo sysctl -w net.inet.tcp.keepcnt=5

    • Apply settings permanently

      Add the following content to /etc/sysctl.conf.

      echo "net.inet.tcp.keepidle = 600" >> /etc/sysctl.conf
      echo "net.inet.tcp.keepintvl = 60" >> /etc/sysctl.conf
      echo "net.inet.tcp.keepcnt = 5" >> /etc/sysctl.conf

  • Application-level settings

    You can use language-specific APIs to set TCP Keepalive parameters for a single connection.

    Java

    The Java standard library has limited support for TCP Keepalive. However, you can implement it by using reflection or low-level socket options.

    Note

    The following code requires system support for options such as tcp_keepidle on Linux or FreeBSD. Additionally, some methods, such as reflection, may not work due to differences in JVM versions. We recommend that you test for compatibility before use in a production environment.

    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.net.Socket;
    import java.net.SocketOption;
    import java.nio.channels.SocketChannel;
    public class TcpKeepaliveExample {
        public static void main(String[ ] args) {
            try (Socket socket = new Socket()) {
                // 1. Enable Keepalive
                socket.setKeepAlive(true);
                // 2. Set Keepalive parameters (requires low-level socket options)
                SocketChannel channel = socket.getChannel();
                if (channel != null) {
                    // Set Keepidle (idle time)
                    channel.setOption(StandardSocketOptions.SO_KEEPALIVE, true); // Keepalive must be enabled first
                    setSocketOptionInt(socket, "tcp_keepidle", 600); // Requires system support
                    // Set Keepintvl (retransmission interval)
                    setSocketOptionInt(socket, "tcp_keepintvl", 60);
                    // Set Keepcount (number of failures)
                    setSocketOptionInt(socket, "tcp_keepcnt", 5); // Note: The parameter name may vary by system
                }
                // Connect to the server
                socket.connect(new InetSocketAddress("example.com", 80));
                // ... Other operations ...
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        // Use reflection to set system-specific socket options (such as on Linux/FreeBSD)
        private static void setSocketOptionInt(Socket socket, String optionName, int value) {
            try {
                Class<?> clazz = Class.forName("java.net.Socket$SocketOptions");
                Object options = clazz.getDeclaredMethod("options").invoke(socket);
                Class<?> optionsClass = options.getClass();
                optionsClass.getDeclaredMethod("setOption", String.class, int.class)
                        .invoke(options, optionName, value);
            } catch (Exception e) {
                throw new RuntimeException("Failed to set socket option " + optionName, e);
            }
        }
    }

    Python

    The Python socket module supports direct configuration of TCP Keepalive parameters.

    Note

    Different operating systems may use different parameter names. For example, macOS may require TCP_KEEPALIVE instead of TCP_KEEPIDLE. Some parameters may require root permissions to set.

    import socket
    def create_keepalive_socket():
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 1. Enable Keepalive
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
        # 2. Set Keepalive parameters (Linux/FreeBSD)
        # Keepidle: 600 seconds
        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 600)
        # Keepintvl: 60 seconds
        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 60)
        # Keepcount: 5
        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 5)
        return sock
    # Example
    sock = create_keepalive_socket()
    sock.connect(("example.com", 80))
    # ... Other operations ...
    sock.close()

    Golang

    The Golang net package provides basic Keepalive configuration. However, you must use the low-level syscall package to set detailed parameters.

    Note

    Different operating systems may use different parameter names. Some parameters may require root permissions to set.

    package main
    import (
        "fmt"
        "net"
        "syscall"
    )
    func main() {
        // Create a TCP connection
        conn, err := net.Dial("tcp", "example.com:80")
        if err != nil {
            panic(err)
        }
        defer conn.Close()
        // Get the underlying file descriptor
        file, err := conn.(*net.TCPConn).File()
        if err != nil {
            panic(err)
        }
        defer file.Close()
        fd := int(file.Fd())
    
        // Enable Keepalive
        err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_KEEPALIVE, 1)
        if err != nil {
            panic(fmt.Errorf("set SO_KEEPALIVE: %v", err))
        }
        // Set Keepidle (idle time)
        err = syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPIDLE, 600)
        if err != nil {
            panic(fmt.Errorf("set TCP_KEEPIDLE: %v", err))
        }
        // Set Keepintvl (retransmission interval)
        err = syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPINTVL, 60)
        if err != nil {
            panic(fmt.Errorf("set TCP_KEEPINTVL: %v", err))
        }
        // Set Keepcount (number of failures)
        err = syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPCNT, 5)
        if err != nil {
            panic(fmt.Errorf("set TCP_KEEPCNT: %v", err))
        }
        // ... Other operations ...
    }

"Not a OLAP table" error during data backup

• Symptom: When you back up data by creating a snapshot in StarRocks, you receive the following error message:

  Unexpected exception: Table '<table_name>' is not a OLAP table

• Causes:

  • The instance is in shared-data mode.

    StarRocks shared-data instances do not support data backup and recovery. This feature is only available for shared-nothing instances.

  • The table engine type is incompatible.

    The StarRocks backup feature only supports tables that use the OLAP engine. This error occurs if the table engine is not OLAP.

• Solution:

  • Check the instance type.

    In the StarRocks Instance List, check the Instance Type. If the instance is of the Shared-data type, it does not support data backup and recovery. We recommend using a shared-nothing instance to enable backup and recovery. For more information, see Backup and recovery.

  • Check the table engine type.

    Examine the DDL definition of the target table to confirm if ENGINE=OLAP is set.

    SHOW CREATE TABLE <table_name>;

    If the table engine is not OLAP, recreate the table according to your business needs and ensure that you specify ENGINE=OLAP.