Java Code类代码示例

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
@Test
public void testBasicIntp() {
  assertEquals(InterpreterResult.Code.SUCCESS,
      repl.interpret("val a = 1\nval b = 2", context).code());

  // when interpret incomplete expression
  InterpreterResult incomplete = repl.interpret("val a = \"\"\"", context);
  assertEquals(InterpreterResult.Code.INCOMPLETE, incomplete.code());
  assertTrue(incomplete.message().length() > 0); // expecting some error
                                                 // message
  /*
   * assertEquals(1, repl.getValue("a")); assertEquals(2, repl.getValue("b"));
   * repl.interpret("val ver = sc.version");
   * assertNotNull(repl.getValue("ver")); assertEquals("HELLO\n",
   * repl.interpret("println(\"HELLO\")").message());
   */
}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
@Test
public void testSparkSql(){
  repl.interpret("case class Person(name:String, age:Int)\n", context);
  repl.interpret("val people = sc.parallelize(Seq(Person(\"moon\", 33), Person(\"jobs\", 51), Person(\"gates\", 51), Person(\"park\", 34)))\n", context);
  assertEquals(Code.SUCCESS, repl.interpret("people.take(3)", context).code());


  if (getSparkVersionNumber() <= 11) { // spark 1.2 or later does not allow create multiple SparkContext in the same jvm by default.
  // create new interpreter
  Properties p = new Properties();
  SparkInterpreter repl2 = new SparkInterpreter(p);
  repl2.open();

  repl.interpret("case class Man(name:String, age:Int)", context);
  repl.interpret("val man = sc.parallelize(Seq(Man(\"moon\", 33), Man(\"jobs\", 51), Man(\"gates\", 51), Man(\"park\", 34)))", context);
  assertEquals(Code.SUCCESS, repl.interpret("man.take(3)", context).code());
  repl2.getSparkContext().stop();
  }
}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
@Test
public void testDefault() {
  dep.getDependencyContext().reset();
  InterpreterResult ret = dep.interpret("z.load(\"org.apache.commons:commons-csv:1.1\")", context);
  assertEquals(Code.SUCCESS, ret.code());

  assertEquals(1, dep.getDependencyContext().getFiles().size());
  assertEquals(1, dep.getDependencyContext().getFilesDist().size());

  // Add a test for the spark-packages repo - default in additionalRemoteRepository
  ret = dep.interpret("z.load(\"amplab:spark-indexedrdd:0.3\")", context);
  assertEquals(Code.SUCCESS, ret.code());

  // Reset at the end of the test
  dep.getDependencyContext().reset();
}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
@Test
public void should_interpret_simple_select() throws Exception {
    //Given

    //When
    final InterpreterResult actual = interpreter.interpret("SELECT * FROM " + ARTISTS_TABLE + " LIMIT 10;", intrContext);

    //Then
    assertThat(actual).isNotNull();
    assertThat(actual.code()).isEqualTo(Code.SUCCESS);
    assertThat(actual.message()).isEqualTo("name\tborn\tcountry\tdied\tgender\tstyles\ttype\n" +
            "Bogdan Raczynski\t1977-01-01\tPoland\tnull\tMale\t[Dance, Electro]\tPerson\n" +
            "Krishna Das\t1947-05-31\tUSA\tnull\tMale\t[Unknown]\tPerson\n" +
            "Sheryl Crow\t1962-02-11\tUSA\tnull\tFemale\t[Classic, Rock, Country, Blues, Pop, Folk]\tPerson\n" +
            "Doof\t1968-08-31\tUnited Kingdom\tnull\tnull\t[Unknown]\tPerson\n" +
            "House of Large Sizes\t1986-01-01\tUSA\t2003\tnull\t[Unknown]\tGroup\n" +
            "Fanfarlo\t2006-01-01\tUnited Kingdom\tnull\tnull\t[Rock, Indie, Pop, Classic]\tGroup\n" +
            "Jeff Beck\t1944-06-24\tUnited Kingdom\tnull\tMale\t[Rock, Pop, Classic]\tPerson\n" +
            "Los Paranoias\tnull\tUnknown\tnull\tnull\t[Unknown]\tnull\n" +
            "…And You Will Know Us by the Trail of Dead\t1994-01-01\tUSA\tnull\tnull\t[Rock, Pop, Classic]\tGroup\n");

}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
@Test
public void should_interpret_multiple_statements_with_single_line_logged_batch() throws Exception {
    //Given
    String statements = "CREATE TABLE IF NOT EXISTS zeppelin.albums(\n" +
            "    title text PRIMARY KEY,\n" +
            "    artist text,\n" +
            "    year int\n" +
            ");\n" +
            "BEGIN BATCH"+
            "   INSERT INTO zeppelin.albums(title,artist,year) VALUES('The Impossible Dream EP','Carter the Unstoppable Sex Machine',1992);"+
            "   INSERT INTO zeppelin.albums(title,artist,year) VALUES('The Way You Are','Tears for Fears',1983);"+
            "   INSERT INTO zeppelin.albums(title,artist,year) VALUES('Primitive','Soulfly',2003);"+
            "APPLY BATCH;\n"+
            "SELECT * FROM zeppelin.albums;";
    //When
    final InterpreterResult actual = interpreter.interpret(statements, intrContext);

    //Then
    assertThat(actual.code()).isEqualTo(Code.SUCCESS);
    assertThat(actual.message()).isEqualTo("title\tartist\tyear\n" +
            "The Impossible Dream EP\tCarter the Unstoppable Sex Machine\t1992\n" +
            "The Way You Are\tTears for Fears\t1983\n" +
            "Primitive\tSoulfly\t2003\n");
}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
@Test
public void should_execute_prepared_and_bound_statements() throws Exception {
    //Given
    String queries = "@prepare[ps]=INSERT INTO zeppelin.prepared(key,val) VALUES(?,?)\n" +
            "@prepare[select]=SELECT * FROM zeppelin.prepared WHERE key=:key\n" +
            "@bind[ps]='myKey','myValue'\n" +
            "@bind[select]='myKey'";

    //When
    final InterpreterResult actual = interpreter.interpret(queries, intrContext);

    //Then
    assertThat(actual.code()).isEqualTo(Code.SUCCESS);
    assertThat(actual.message()).isEqualTo("key\tval\n" +
            "myKey\tmyValue\n");
}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
@Test
public void should_extract_variable_from_statement() throws Exception {
    //Given
    when(intrContext.getGui().input("login", "hsue")).thenReturn("hsue");
    when(intrContext.getGui().input("age", "27")).thenReturn("27");

    String queries = "@prepare[test_insert_with_variable]=" +
            "INSERT INTO zeppelin.users(login,firstname,lastname,age) VALUES(?,?,?,?)\n" +
            "@bind[test_insert_with_variable]='{{login=hsue}}','Helen','SUE',{{age=27}}\n" +
            "SELECT firstname,lastname,age FROM zeppelin.users WHERE login='hsue';";
    //When
    final InterpreterResult actual = interpreter.interpret(queries, intrContext);

    //Then
    assertThat(actual.code()).isEqualTo(Code.SUCCESS);
    assertThat(actual.message()).isEqualTo("firstname\tlastname\tage\n" +
            "Helen\tSUE\t27\n");

}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
@Test
public void should_execute_bound_statement_with_no_bound_value() throws Exception {
    //Given
    String queries = "@prepare[select_no_bound_value]=SELECT name,country,styles FROM zeppelin.artists LIMIT 3\n" +
            "@bind[select_no_bound_value]";

    //When
    final InterpreterResult actual = interpreter.interpret(queries, intrContext);

    //Then
    assertThat(actual.code()).isEqualTo(Code.SUCCESS);
    assertThat(actual.message()).isEqualTo("name\tcountry\tstyles\n" +
            "Bogdan Raczynski\tPoland\t[Dance, Electro]\n" +
            "Krishna Das\tUSA\t[Unknown]\n" +
            "Sheryl Crow\tUSA\t[Classic, Rock, Country, Blues, Pop, Folk]\n");

}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
@Test
public void should_fail_when_executing_a_removed_prepared_statement() throws Exception {
    //Given
    String prepare_first = "@prepare[to_be_removed]=INSERT INTO zeppelin.users(login,deceased) VALUES(?,?)";
    interpreter.interpret(prepare_first, intrContext);
    String remove_prepared = "@remove_prepare[to_be_removed]\n" +
            "@bind[to_be_removed]='bind_bool'";

    //When
    final InterpreterResult actual = interpreter.interpret(remove_prepared, intrContext);

    //Then
    assertThat(actual.code()).isEqualTo(Code.ERROR);
    assertThat(actual.message()).isEqualTo("The statement 'to_be_removed' can not be bound to values. " +
            "Are you sure you did prepare it with @prepare[to_be_removed] ?");
}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
@Test
public void should_display_statistics_for_non_select_statement() throws Exception {
    //Given
    String query = "USE zeppelin;\nCREATE TABLE IF NOT EXISTS no_select(id int PRIMARY KEY);";
    final String rawResult = reformatHtml(readTestResource("/scalate/NoResultWithExecutionInfo.html"));

    //When
    final InterpreterResult actual = interpreter.interpret(query, intrContext);
    final Cluster cluster = session.getCluster();
    final int port = cluster.getConfiguration().getProtocolOptions().getPort();
    final String address = cluster.getMetadata().getAllHosts().iterator().next()
            .getAddress().getHostAddress()
            .replaceAll("/", "").replaceAll("\\[", "").replaceAll("\\]","");
    //Then
    final String expected = rawResult.replaceAll("TRIED_HOSTS", address+":"+port)
            .replaceAll("QUERIED_HOSTS", address +":"+port);


    assertThat(actual.code()).isEqualTo(Code.SUCCESS);
    assertThat(reformatHtml(actual.message())).isEqualTo(expected);
}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
@Test
public void should_describe_cluster() throws Exception {
    //Given

    String query = "DESCRIBE CLUSTER;";
    final String expected = reformatHtml(
            readTestResource("/scalate/DescribeCluster.html"));

    //When
    final InterpreterResult actual = interpreter.interpret(query, intrContext);

    //Then
    assertThat(actual.code()).isEqualTo(Code.SUCCESS);

    assertThat(reformatHtml(actual.message())).isEqualTo(expected);
}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
@Test
public void should_describe_udt_withing_logged_in_keyspace() throws Exception {
    //Given
    String query = "USE live_data;\n" +
            "DESCRIBE TYPE address;";
    final String expected = reformatHtml(
            readTestResource("/scalate/DescribeType_live_data_address_within_current_keyspace.html"));

    //When
    final InterpreterResult actual = interpreter.interpret(query, intrContext);

    //Then
    assertThat(actual.code()).isEqualTo(Code.SUCCESS);

    assertThat(reformatHtml(actual.message())).isEqualTo(expected);
}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
@Test
public void testAgg() {

  // Single-value metric
  InterpreterResult res = interpreter.interpret("search /logs { \"aggs\" : { \"distinct_status_count\" : " +
          " { \"cardinality\" : { \"field\" : \"status\" } } } }", null);
  assertEquals(Code.SUCCESS, res.code());

  // Multi-value metric
  res = interpreter.interpret("search /logs { \"aggs\" : { \"content_length_stats\" : " +
          " { \"extended_stats\" : { \"field\" : \"content_length\" } } } }", null);
  assertEquals(Code.SUCCESS, res.code());

  // Single bucket
  res = interpreter.interpret("search /logs { \"aggs\" : { " +
          " \"200_OK\" : { \"filter\" : { \"term\": { \"status\": \"200\" } }, " +
          "   \"aggs\" : { \"avg_length\" : { \"avg\" : { \"field\" : \"content_length\" } } } } } }", null);
  assertEquals(Code.SUCCESS, res.code());

  // Multi-buckets
  res = interpreter.interpret("search /logs { \"aggs\" : { \"status_count\" : " +
          " { \"terms\" : { \"field\" : \"status\" } } } }", null);
  assertEquals(Code.SUCCESS, res.code());
}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
private InterpreterResult executeSql(String sql) {
  try {
    Either<String, Either<Joiner4All, Mapper4All>> result = dDriver.query(sql, null);
    if (result.isLeft()) {
      return new InterpreterResult(Code.ERROR, result.left().get().toString());
    }
    Either<Joiner4All, Mapper4All> goodResult =
        (Either<Joiner4All, Mapper4All>) result.right().get();
    if (goodResult.isLeft()) {
      return new InterpreterResult(Code.SUCCESS, goodResult.left().get().toString());
    } else {
      return new InterpreterResult(Code.SUCCESS,
        mapper4All2Zeppelin((Mapper4All) goodResult.right().get()));
    }

  } catch (Exception e) {
    return new InterpreterResult(Code.ERROR, e.getMessage());
  }

}
 

import org.apache.zeppelin.interpreter.InterpreterResult.Code; //导入依赖的package包/类
private InterpreterResult HandleHelp(JLineShell shell, String st) {
  java.util.logging.StreamHandler sh = null;
  java.util.logging.Logger springLogger = null;
  java.util.logging.Formatter formatter = new java.util.logging.Formatter() {
    public String format(java.util.logging.LogRecord record) {
      return record.getMessage();
    }
  };
  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  try {
    sh = new java.util.logging.StreamHandler(baos, formatter);
    springLogger = HandlerUtils.getLogger(org.springframework.shell.core.SimpleParser.class);
    springLogger.addHandler(sh);
    shell.executeCommand(st);
  } catch (Exception e) {
    s_logger.error(e.getMessage(), e);
    return new InterpreterResult(Code.ERROR, e.getMessage());
  }
  finally {
    sh.flush();
    springLogger.removeHandler(sh);
    sh.close();
  }
  return new InterpreterResult(Code.SUCCESS, baos.toString());
}