Best code snippets using com.facebook.presto.sql.QueryUtil.identifier(Showing top 15 results out of 315)

@Test
public void testPrepareWithParameters()
{
  assertStatement("PREPARE myquery FROM SELECT ?, ? FROM foo",
      new Prepare(identifier("myquery"), simpleQuery(
          selectList(new Parameter(0), new Parameter(1)),
          table(QualifiedName.of("foo")))));
}

@Test
public void testCreateTableNotExistsTrue()
{
  CreateTable statement = new CreateTable(QualifiedName.of("test_table"),
      ImmutableList.of(new ColumnDefinition(identifier("a"), "BIGINT", Optional.empty())),
      true,
      ImmutableList.of(),
      Optional.empty());
  getFutureValue(new CreateTableTask().internalExecute(statement, metadata, new AllowAllAccessControl(), testSession, emptyList()));
  assertEquals(metadata.getCreateTableCallCount(), 1);
}

@Test
public void testRevoke()
{
  assertStatement("REVOKE INSERT, DELETE ON t FROM u",
      new Revoke(false, Optional.of(ImmutableList.of("INSERT", "DELETE")), false, QualifiedName.of("t"), identifier("u")));
  assertStatement("REVOKE GRANT OPTION FOR SELECT ON t FROM PUBLIC",
      new Revoke(true, Optional.of(ImmutableList.of("SELECT")), false, QualifiedName.of("t"), identifier("PUBLIC")));
  assertStatement("REVOKE ALL PRIVILEGES ON TABLE t FROM u",
      new Revoke(false, Optional.empty(), true, QualifiedName.of("t"), identifier("u")));
  assertStatement("REVOKE taco ON TABLE t FROM u",
      new Revoke(false, Optional.of(ImmutableList.of("taco")), true, QualifiedName.of("t"), identifier("u")));
}

@Test
public void testShowSchemas()
{
  assertStatement("SHOW SCHEMAS", new ShowSchemas(Optional.empty(), Optional.empty()));
  assertStatement("SHOW SCHEMAS FROM foo", new ShowSchemas(Optional.of(identifier("foo")), Optional.empty()));
  assertStatement("SHOW SCHEMAS IN foo LIKE '%'", new ShowSchemas(Optional.of(identifier("foo")), Optional.of("%")));
}

public static Relation aliased(Relation relation, String alias, List<String> columnAliases)
{
  return new AliasedRelation(
      relation,
      identifier(alias),
      columnAliases.stream()
          .map(QueryUtil::identifier)
          .collect(Collectors.toList()));
}

@Test
public void testAddColumn()
{
  assertStatement("ALTER TABLE foo.t ADD COLUMN c bigint", new AddColumn(QualifiedName.of("foo", "t"), new ColumnDefinition(identifier("c"), "bigint", Optional.empty())));
}

@Test
public void testExecuteWithUsing()
{
  assertStatement("EXECUTE myquery USING 1, 'abc', ARRAY ['hello']",
      new Execute(identifier("myquery"), ImmutableList.of(new LongLiteral("1"), new StringLiteral("abc"), new ArrayConstructor(ImmutableList.of(new StringLiteral("hello"))))));
}

@Test
public void testDropColumn()
{
  assertStatement("ALTER TABLE foo.t DROP COLUMN c", new DropColumn(QualifiedName.of("foo", "t"), identifier("c")));
  assertStatement("ALTER TABLE \"t x\" DROP COLUMN \"c d\"", new DropColumn(QualifiedName.of("t x"), quotedIdentifier("c d")));
}

@Test
public void testPrepare()
{
  assertStatement("PREPARE myquery FROM select * from foo",
      new Prepare(identifier("myquery"), simpleQuery(
          selectList(new AllColumns()),
          table(QualifiedName.of("foo")))));
}

@Test
public void testRenameSchema()
{
  assertStatement("ALTER SCHEMA foo RENAME TO bar",
      new RenameSchema(QualifiedName.of("foo"), identifier("bar")));
  assertStatement("ALTER SCHEMA foo.bar RENAME TO baz",
      new RenameSchema(QualifiedName.of("foo", "bar"), identifier("baz")));
  assertStatement("ALTER SCHEMA \"awesome schema\".\"awesome table\" RENAME TO \"even more awesome table\"",
      new RenameSchema(QualifiedName.of("awesome schema", "awesome table"), quotedIdentifier("even more awesome table")));
}

@Test
public void testDescribeInput()
{
  assertStatement("DESCRIBE INPUT myquery", new DescribeInput(identifier("myquery")));
}

@Test
public void testExecute()
{
  assertStatement("EXECUTE myquery", new Execute(identifier("myquery"), emptyList()));
}

@Test
public void testGrant()
{
  assertStatement("GRANT INSERT, DELETE ON t TO u",
      new Grant(Optional.of(ImmutableList.of("INSERT", "DELETE")), false, QualifiedName.of("t"), identifier("u"), false));
  assertStatement("GRANT SELECT ON t TO PUBLIC WITH GRANT OPTION",
      new Grant(Optional.of(ImmutableList.of("SELECT")), false, QualifiedName.of("t"), identifier("PUBLIC"), true));
  assertStatement("GRANT ALL PRIVILEGES ON t TO u",
      new Grant(Optional.empty(), false, QualifiedName.of("t"), identifier("u"), false));
  assertStatement("GRANT taco ON t TO PUBLIC WITH GRANT OPTION",
      new Grant(Optional.of(ImmutableList.of("taco")), false, QualifiedName.of("t"), identifier("PUBLIC"), true));
}

@Test
public void testDescribeOutput()
{
  assertStatement("DESCRIBE OUTPUT myquery", new DescribeOutput(identifier("myquery")));
}

@Test
public void testDeallocatePrepare()
{
  assertStatement("DEALLOCATE PREPARE myquery", new Deallocate(identifier("myquery")));
}