最近很多小伙伴都在问htablerecreate这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展Can''tcreatetable''table_name'';tableexist

最近很多小伙伴都在问htable recreate这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展Can''t create table ''table_name''; table exists - 如何解决MySQL报错：无法创建表，表已存在、com.facebook.presto.sql.tree.CreateTableAsSelect的实例源码、create table、CREATE TABLE - 定义一个新表等相关知识，下面开始了哦！

• htable recreate
• Can''t create table ''table_name''; table exists - 如何解决MySQL报错：无法创建表，表已存在
• com.facebook.presto.sql.tree.CreateTableAsSelect的实例源码
• create table
• CREATE TABLE - 定义一个新表

htable recreate

#!/bin/bash #usage: recreate htable #$1:hbaseTableName TABLENAME=$1 HADOOP_CLASSPATH=hbase classpath echo " disable ''${TABLENAME}'' snapshot ''${TABLENAME}'', ''${TABLENAME}Snap'' clone_snapshot ''${TABLENAME}Snap'', ''${TABLENAME}New'' delete_snapshot ''${TABLENAME}Snap'' drop ''${TABLENAME}'' create ''${TABLENAME}'',{ NAME => ''f'', COMPRESSION => ''snappy'', IN_MEMORY => true }, {NUMREGIONS => 75, SPLITALGO => ''HexStringSplit''} "|hbase shell HADOOP_CLASSPATH=hbase classpath hbase org.apache.hadoop.hbase.mapreduce.CopyTable --new.name=${TABLENAME} ${TABLENAME}New

Can''t create table ''table_name''; table exists - 如何解决MySQL报错：无法创建表，表已存在

Can''t create table ''table_name''; table exists - 如何解决MySQL报错：无法创建表，表已存在，需要具体代码示例

MySQL是最常用的关系型数据库之一，具有广泛的应用。在使用MySQL时，有时会遇到报错信息："Can''t create table ''table_name''; table exists"，意思是无法创建表，因为表已经存在。这种错误信息通常出现在我们尝试创建一个已经存在的表时。本文将介绍如何解决这个问题，并提供相应的代码示例。

首先，让我们了解一下MySQL的CREATE TABLE语句的基本语法：

CREATE TABLE table_name (

column1 datatype constraints,
column2 datatype constraints,
...

);

其中，table_name是你要创建的表的名称，column1、column2等是表中的列，datetype是列的数据类型，而constraints是列的约束条件。

当我们执行CREATE TABLE语句时，MySQL会尝试创建一个新的表。如果指定的表名已经存在，MySQL将报错，并提示无法创建表，因为表已存在。

为了解决这个问题，我们可以使用以下两种方法之一：

方法一：删除已存在的表
在创建表之前，我们可以先检查表是否已经存在，然后再做相应的操作。若表存在，我们可以先删除它，然后再重新创建。

下面是一个示例代码：

DROP TABLE IF EXISTS table_name;
CREATE TABLE table_name (

column1 datatype constraints,
column2 datatype constraints,
...

);

在上面的代码中，我们首先使用DROP TABLE语句检查并删除已存在的表。如果表存在，则会被删除。接下来，我们使用CREATE TABLE语句创建一个新的表。

方法二：使用CREATE TABLE IF NOT EXISTS语句
CREATE TABLE IF NOT EXISTS是一个MySQL的扩展语句，它能够检查表是否存在。如果表不存在，它会创建一个新表；如果表已经存在，则不做任何操作。

下面是一个示例代码：

CREATE TABLE IF NOT EXISTS table_name (

column1 datatype constraints,
column2 datatype constraints,
...

);

上述代码中，我们使用了CREATE TABLE IF NOT EXISTS语句来创建一个新表。如果表已经存在，则不进行任何操作。

综上所述，解决MySQL报错："Can''t create table ''table_name''; table exists"，无法创建表因为表已经存在的问题，我们可以使用DELETE语句删除已存在的表，或者使用CREATE TABLE IF NOT EXISTS语句来判断表是否存在，并分别执行相应的操作。以下是一个完整的示例代码，演示了如何使用这两种方法：

方法一：删除已存在的表

DROP TABLE IF EXISTS table_name;
CREATE TABLE table_name (

column1 datatype constraints,
column2 datatype constraints,
...

);

方法二：使用CREATE TABLE IF NOT EXISTS语句

CREATE TABLE IF NOT EXISTS table_name (

column1 datatype constraints,
column2 datatype constraints,
...

);

无论你选择哪种方法，都可以解决MySQL报错："Can''t create table ''table_name''; table exists"的问题。根据你的具体需求和数据情况，选择合适的方法来解决问题，并确保正确地创建表。

以上就是Can''t create table ''table_name''; table exists - 如何解决MySQL报错：无法创建表，表已存在的详细内容，更多请关注php中文网其它相关文章！

com.facebook.presto.sql.tree.CreateTableAsSelect的实例源码

/**
 * Creates a table based on a select on another type and inserts the data (currently not possible to
 * perform this action 'WITH NO DATA'.
 * @param sql
 * @param createAsSelect
 * @param index
 * @return the number of rows inserted
 * @throws sqlException
 */
public int execute(String sql,CreateTableAsSelect createAsSelect,String index) throws sqlException {
    if(!createAsSelect.isWithData()) throw new sqlException("Not yet possible to create table as select without data (create emtpy table,"
            + "insert data and delete it will have the same effect");
    // first create the index
    sqlParser parser = new sqlParser();
    int queryIdx = sql.toLowerCase().indexOf(" as ");
    try{
        String createsql = sql.substring(0,queryIdx)+" (_id String)" ;
        CreateTable create = (CreateTable)parser.createStatement(createsql);
        this.execute(createsql,create,index);

    }catch(sqlException sqle) {
        throw sqle;
    }catch(Exception e){
        throw new sqlException("Unable to create table due to: "+e.getMessage(),e);
    }

    // secondly add the documents from the query
    String insertsql = "INSERT INTO "+createAsSelect.getName().toString()+" "+sql.substring(queryIdx+4);
    Insert insert = (Insert)parser.createStatement(insertsql);
    int res = this.execute(insertsql,insert,index);
    this.statement.getConnection().getTypeMap(); // trigger a reload of the table&column set for the connection
    return res;
}

@Override
protected Void visitCreateTableAsSelect(CreateTableAsSelect node,Integer indent)
{
    builder.append("CREATE TABLE ");
    if (node.isNotExists()) {
        builder.append("IF NOT EXISTS ");
    }
    builder.append(node.getName());

    appendTableProperties(builder,node.getProperties(),indent);

    builder.append(" AS ");
    process(node.getQuery(),indent);

    if (!node.isWithData()) {
        builder.append(" WITH NO DATA");
    }

    return null;
}

@Override
protected Void visitCreateTableAsSelect(CreateTableAsSelect node,Integer indent)
{
    builder.append("CREATE TABLE ")
            .append(node.getName());

    if (!node.getProperties().isEmpty()) {
        builder.append(" WITH (");
        Joiner.on(",").appendTo(builder,transform(node.getProperties().entrySet(),entry -> entry.getKey() + " = " + formatExpression(entry.getValue())));
        builder.append(")");
    }

    builder.append(" AS ");
    process(node.getQuery(),indent);

    if (!node.isWithData()) {
        builder.append(" WITH NO DATA");
    }

    return null;
}

@Override
protected Void visitCreateTableAsSelect(CreateTableAsSelect node,indent);

    if (!node.isWithData()) {
        builder.append(" WITH NO DATA");
    }

    return null;
}

@Override
public int executeUpdate(String sql) throws sqlException {
    //System.out.println("QUERY: ["+sql+"]");
    sql = sql.replaceAll("\r"," ").replaceAll("\n"," ").trim();
    // custom stuff to support UPDATE statements since Presto does not parse it
    if(sql.toLowerCase().startsWith("update")){
        return updateState.execute(sql);
    }

    com.facebook.presto.sql.tree.Statement statement = parser.createStatement(sql);
    if(statement instanceof Query) throw new sqlException("A regular query cannot be executed as an Update");
    if(statement instanceof Insert){
        //if(connection.getSchema() == null) throw new sqlException("No active index set for this driver. Pleas specify an active index or alias by executing 'USE <index/alias>' first");
        return updateState.execute(sql,(Insert)statement,connection.getSchema());
    }else if(statement instanceof Delete){
        if(connection.getSchema() == null) throw new sqlException("No active index set for this driver. Pleas specify an active index or alias by executing 'USE <index/alias>' first");
        return updateState.execute(sql,(Delete)statement,connection.getSchema());
    }else if(statement instanceof CreateTable){
        return updateState.execute(sql,(CreateTable)statement,connection.getSchema());
    }else if(statement instanceof CreateTableAsSelect){
        return updateState.execute(sql,(CreateTableAsSelect)statement,connection.getSchema());
    }else if(statement instanceof CreateView){
        return updateState.execute(sql,(CreateView)statement,connection.getSchema());
    }else if(statement instanceof Use){
        connection.setSchema( ((Use)statement).getSchema());
        //connection.getTypeMap(); // updates the type mappings found in properties
        return 0;
    }else if(statement instanceof DropTable){
        return updateState.execute(sql,(DropTable)statement);
    }else if(statement instanceof DropView){
        return updateState.execute(sql,(DropView)statement);
    }throw new sqlFeatureNotSupportedException("Unable to parse provided update sql");
}

/**
 * Executes the {@link BulkRequest} being hold by this state.
 * @return an integer indicator for each executed request: Statement.SUCCESS_NO_INFO for success,* else Statement.EXECUTE_Failed)
 */
public int[] executeBulk(){
    int[] result = new int[bulkList.size()];
    sqlParser parser = new sqlParser();
    for(int i=0; i<bulkList.size(); i++) try{
        String sql = bulkList.get(i);
        com.facebook.presto.sql.tree.Statement st = parser.createStatement(sql);
        if(st instanceof DropTable){
            this.execute(sql,(DropTable)st);
        }else if(st instanceof DropView){
            this.execute(sql,(DropView)st);
        }else if(st instanceof CreateTable){
            this.execute(sql,(CreateTable)st,this.statement.getConnection().getSchema());
        }else if(st instanceof CreateTableAsSelect){
            this.execute(sql,(CreateTableAsSelect)st,this.statement.getConnection().getSchema());
        }else if(st instanceof CreateView){
            this.execute(sql,(CreateView)st,this.statement.getConnection().getSchema());
        }else if(st instanceof Delete){
            this.execute(sql,(Delete)st,this.statement.getConnection().getSchema());
        }else  if(st instanceof Insert){
            this.execute(sql,(Insert)st,this.statement.getConnection().getSchema());
        }
        result[i]= Statement.SUCCESS_NO_INFO;
    }catch (Exception e){
        result[i] = Statement.EXECUTE_Failed;
    }
    this.clearBulk();
    return result;
}

@Override
protected RelationType visitCreateTableAsSelect(CreateTableAsSelect node,AnalysisContext context)
{
    analysis.setUpdateType("CREATE TABLE");

    // turn this into a query that has a new table writer node on top.
    QualifiedobjectName targetTable = createQualifiedobjectName(session,node,node.getName());
    analysis.setCreateTableDestination(targetTable);

    for (Expression expression : node.getProperties().values()) {
        // analyze table property value expressions which must be constant
        createConstantAnalyzer(Metadata,session)
                .analyze(expression,new RelationType(),context);
    }
    analysis.setCreateTableProperties(node.getProperties());

    Optional<TableHandle> targetTableHandle = Metadata.getTableHandle(session,targetTable);
    if (targetTableHandle.isPresent()) {
        throw new SemanticException(TABLE_ALREADY_EXISTS,"Destination table '%s' already exists",targetTable);
    }
    accessControl.checkCanCreateTable(session.getrequiredTransactionId(),session.getIdentity(),targetTable);

    analysis.setCreateTableAsSelectWithData(node.isWithData());

    // analyze the query that creates the table
    RelationType descriptor = process(node.getQuery(),context);

    validateColumnNames(node,descriptor);

    return new RelationType(Field.newUnqualified("rows",BIGINT));
}

@Override
public Node visitCreateTableAsSelect(sqlbaseParser.CreateTableAsSelectContext context)
{
    return new CreateTableAsSelect(getLocation(context),getQualifiedname(context.qualifiedname()),(Query) visit(context.query()),processtableProperties(context.tableProperties()),context.NO() == null);
}

create table

OSC 请你来轰趴啦！1028 苏州源创会，一起寻宝 AI 时代

创建表

CREATE TABLE - 定义一个新表

SYNOPSIS

CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE table_name (
    { column_name data_type [ DEFAULT default_expr ] [ column_constraint [, ... ] ]
    | table_constraint
    | LIKE parent_table [ { INCLUDING | EXCLUDING } DEFAULTS ] }  [, ... ]
)
[ INHERITS ( parent_table [, ... ] ) ]
[ WITH OIDS | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]

where column_constraint is:

[ CONSTRAINT constraint_name ]
{ NOT NULL | NULL | UNIQUE | PRIMARY KEY |
  CHECK (expression) |
  REFERENCES reftable [ ( refcolumn ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
    [ ON DELETE action ] [ ON UPDATE action ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

and table_constraint is:

[ CONSTRAINT constraint_name ]
{ UNIQUE ( column_name [, ... ] ) |
  PRIMARY KEY ( column_name [, ... ] ) |
  CHECK ( expression ) |
  FOREIGN KEY ( column_name [, ... ] ) REFERENCES reftable [ ( refcolumn [, ... ] ) ]
    [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE action ] [ ON UPDATE action ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

DESCRIPTION 描述

CREATE TABLE 将在当前数据库创建一个新的， 初始为空的表。该表将由发出此命令的用户所有。

 如果给出了模式名（比如，CREATE TABLE myschema.mytable ...）， 那么表是在指定模式中创建的。否则它在当前模式中创建。临时表存在于一个特殊的模式里， 因此创建临时表的时候不能给出模式名。表名字必需和同一模式中其他表，序列，索引或者视图相区别。

CREATE TABLE 还自动创建一个数据类型， 该数据类型代表对应该表一行的复合类型。 因此，表不能和同模式中的现有数据类型同名。

 一个表的字段数不能超过 1600。（实际上，真正的限制比这低，因为还有元组长度的约束）。

 可选的约束子句声明约束（或者测试），新行或者更新的行必须满足这些约束才能成功插入或更新。 约束是一个它是一个 SQL 对象，它以多种方式协助我们协助我们在表上定义有效的数值集合。

 定义约束又两种方法：表约束和列约束。一个列约束是作为一个列定义的一部分定义的。 而表约束并不和某个列绑在一起， 它可以作用于多于一个列上。每个列约束也可以写成表约束； 如果某个约束只影响一个列，那么列约束只是符号上的简洁方式而已。

PARAMETERS 参数

TEMPORARY 或 TEMP

 如果声明了此参数，则该表创建为临时表。临时表在会话结束时自动删除， 或者是（可选）在当前事务的结尾（参阅下面的 ON COMMIT）。 现有同名永久表在临时表存在期间在本会话过程中是不可见的， 除非它们是用模式修饰的名字引用的。 任何在临时表上创建的索引也都会自动删除。

 我们可以选择在 TEMPORARY 或 TEMP 前面放上 GLOBAL 或者 LOCAL。 这样对 PostgreSQL 没有任何区别，可以参阅 Compatibility [create_table(7)]。

table_name

 要创建的表的名字（可以用模式修饰）。

column_name

 在新表中要创建的字段名字。

data_type

 该字段的数据类型。它可以包括数组说明符。

DEFAULT

DEFAULT 子句给它所出现的字段一个缺省数值。 该数值可以是任何不含变量的表达式（不允许使用子查询和对本表中的其它字段的交叉引用）。 缺省表达式的数据类型必须和字段类型匹配。

 缺省表达式将被用于任何未声明该字段数值的插入操作。 如果字段上没有缺省值，那么缺省是 NULL。

LIKE 子句声明一个表，新表自动从这个表里面继承所有字段名， 他们的数据类型，以及非空约束。

 和 INHERITS 不同，新表与继承过来的表之间在创建动作完毕之后是完全无关的。 插入新表的数据不会在父表中表现出来。
 
 字段缺省表达式只有在声明了 INCLUDING DEFAULTS 之后才会继承过来。 缺省是排除缺省表达式。

INHERITS ( parent_table [, ... ] )

 可选的 INHERITS 子句声明一列表，这个新表自动从这列表中继承所有字段。 如果在多于一个父表中存在同名的字段，那么就会报告一个错误，除非这些字段的数据类型在每个父表里都是匹配的。 如果没有冲突，那么重复的字段在新表中融合成一个字段。 如果新表的字段名列表中包括和继承的字段同名的，那么它的数据类型也必须和上面一样与继承字段匹配，并且这些字段定义会融合成一个。 不过，同名的继承和新字段声明可以声明不同的约束：所有的继承过来的约束以及声明的约束都融合到一起，并且全部应用于新表。 如果新表为该字段明确的声明了一个缺省数值，那么此缺省数值覆盖任何来自继承字段声明的缺省值。 否则，任何为该字段声明了缺省数值的父表都必须声明相同的缺省，否则就会报告一个错误。

WITH OIDS

WITHOUT OIDS

 这个可选的子句声明新表中的行是否应该拥有赋予它们的 OID （对象标识）。 缺省是有 OID。（如果新表从任何有 OID 的表继承而来，那么就算这条命令说了 WITHOUT OIDS， 也会强制 WITH OIDS。）

 声明 WITHOUT OIDS 允许用户禁止为行或者表生成 OID。 这么做对大表是值得的，因为这样可以减少 OID 消耗并且推迟 32 位 OID 计数器的消耗。 一旦该计数器重叠，那么就不能再假设 OID 的唯一，这样它的实用性就大打折扣。 声明 WITHOUT OIDS 还会减少在磁盘上存储每行的空间，每行减少 4 字节，因此也可以改进性能。

CONSTRAINT constraint_name

 列或表约束的可选名字。如果没有声明，则由系统生成一个名字。

NOT NULL

 字段不允许包含 NULL 数值。

NULL

 该字段允许包含 NULL 数值。这是缺省。

 这个子句的存在只是为和那些非标准 SQL 数据库兼容。 我们不建议在新应用中使用它。

UNIQUE (column constraint)

UNIQUE ( column_name [, ... ] ) (table constraint)

UNIQUE 声明一个规则，表示一个表里的一个或者多个独立的字段组合的分组只能包含唯一的数值。 表的唯一约束的行为和列约束的一样，只不过多了跨多行的能力。

 对于唯一约束的用途而言，系统认为 NULL 数值是不相等的。

 每个唯一表约束都必须命名一个字段的集合，该集合必须和其它唯一约束命名字段集合或者该表定义的主键约束不同。 （否则就只是同样的约束写了两次。）

PRIMARY KEY (column constraint)

PRIMARY KEY ( column_name [, ... ] ) (table constraint)

 主键约束表明表中的一个或者一些字段只能包含唯一（不重复）非 NULL 的数值。 从技术上讲，PRIMARY KEY 只是 UNIQUE 和 NOT NULL 的组合，不过把一套字段标识为主键同时也体现了模式设计的元数据， 因为主键意味着其它表可以拿这套字段用做行的唯一标识。

 一个表只能声明一个主键，不管是作为字段约束还是表约束。

 主键约束应该定义在同个表上的一个与其它唯一约束所定义的不同的字段集合上。

CHECK ( expression )

CHECK 约束声明一个生成布尔结果的子句， 一次插入或者更新操作若想成功则里面的新行或者被更新的行必须满足这个条件。 声明为字段约束的检查约束应该只引用该字段的数值，而在表约束里出现的表达式可以引用多个字段。

 目前，CHECK 表达式不能包含子查询也不能引用除当前行字段之外的变量。

REFERENCES reftable [ ( refcolumn ) ] [ MATCH matchtype ] [ ON DELETE action ] [ ON UPDATE action ] (column constraint)

FOREIGN KEY ( column [, ... ] )

 这些子句声明一个外键约束，外键约束声明一个由新表中一列或者多列组成的组应该只包含匹配引用的表 reftable 中对应引用的字段 refcolumn 中的数值。 如果省略 refcolumn， 则使用 reftable 的主键。 被引用字段必须是被引用表中的唯一字段或者主键。

 向这些字段插入的数值将使用给出的匹配类型与参考表中的参考列中的数值进行匹配。 有三种匹配类型：MATCH FULL， MATCH PARTIAL，和 MATCH SIMPLE，它也是缺省匹配类型。 MATCH FULL 将不允许一个多字段外键的字段为 NULL，除非所有外键字段都为 NULL。 MATCH SIMPLE 允许某些外键字段为 NULL 而外键的其它部分不是 NULL。MATCH PARTIAL  还没实现。

 另外，当被参考字段中的数据改变的时候，那么将对本表的字段中的数据执行某种操作。 ON DELETE 子句声明当被参考表中的被参考行将被删除的时候要执行的操作。 类似，ON UPDATE 子句声明被参考表中被参考字段更新为新值的时候要执行的动作。 如果该行被更新，但被参考的字段实际上没有变化，那么就不会有任何动作。 下面是每个子句的可能的动作：

NO ACTION

 生成一个错误，表明删除或者更新将产生一个违反外键约束的动作。 它是缺省动作。

RESTRICT

 和 NO ACTION 一样，只是动作不可推迟， 即使约束剩下的部分是可以推迟的也马上发生。

CASCADE

 删除任何引用了被删除行的行，或者分别把引用行的字段值更新为被参考字段的新数值。

SET NULL

 把引用行数值设置为 NULL。

SET DEFAULT

 把引用列的数值设置为它们的缺省值。

 如果主键字段经常更新，那么我们给 REFERENCES  字段增加一个索引可能是合适的，这样与 REFERENCES 字段相关联的 NO ACTION  和 CASCADE 动作可以更有效地执行。

DEFERRABLE

NOT DEFERRABLE

 这两个关键字设置该约束是否可推迟。一个不可推迟的约束将在每条命令之后马上检查。 可以推迟的约束检查可以推迟到事务结尾（使用 SET CONSTRAINTS [ set_constraints(7)]  命令）。 缺省是 NOT DEFERRABLE。目前只有外键约束接受这个子句。所有其它约束类型都是不可推迟的。

INITIALLY IMMEDIATE

INITIALLY DEFERRED

 如果约束是可推迟的，那么这个子句声明检查约束的缺省时间。 如果约束是 INITIALLY IMMEDIATE， 那么每条语句之后就检查它。这个是缺省。如果约束是 INITIALLY DEFERRED，那么只有在事务结尾才检查它。 约束检查的时间可以用 SET CONSTRAINTS [ set_constraints(7)] 命令修改。

ON COMMIT

 我们可以用 ON COMMIT 控制临时表在事务块结尾的行为。这三个选项是：

PRESERVE ROWS

 在事务结尾不发生任何特定的动作。这是缺省行为。

DELETE ROWS

 临时表的所有行在每次事务结尾都被删除。实际上，在每次提交的时候都自动  truncate(7)  。

DROP

 在当前事务块的结尾，临时表将被删除。

NOTES 注意

*

 如果一个应用使用了 OID 标识表中的特定行，那么我们建议在该表的 oid 字段上创建一个唯一约束，以确保该表的 OID 即使在计数器重叠之后也是唯一的。如果你需要一个整个数据库范围的唯一标识， 那么就要避免假设 OID 是跨表唯一的，你可以用 tableoid 和行 OID 的组合来实现这个目的。 （将来的 PostgreSQL 很可能为每个表使用独立的 OID 计数器， 因此包括 tableoid 组成数据库范围内的唯一标识将是必须的，而不是可选的。）

 

提示: 对那些没有主键的表，我们不建议使用 WITHOUT OIDS， 因为如果既没有 OID 又没有唯一数据键字，那么就很难标识特定的行。

 

*

PostgreSQL 自动为每个唯一约束和主键约束创建一个索引以确保唯一性。 因此，我们不必为主键字段创建明确的索引。（参阅 CREATE INDEX [ create_index(7)]获取更多信息。）

*

 唯一约束和主键在目前的实现里是不能继承的。 这样，如果把继承和唯一约束组合在一起会导致无法运转。

EXAMPLES 例子

 创建表 films 和 distributors：

CREATE TABLE films (
    code        char(5) CONSTRAINT firstkey PRIMARY KEY,
    title       varchar(40) NOT NULL,
    did         integer NOT NULL,
    date_prod   date,
    kind        varchar(10),
    len         interval hour to minute
);

CREATE TABLE distributors (
     did    integer PRIMARY KEY DEFAULT nextval(''serial''),
     name   varchar(40) NOT NULL CHECK (name <> '''')
);

 创建一个带有 2 维数组的表：

CREATE TABLE array (
    vector  int[][]
);

 为表 films 定义一个唯一表约束。 唯一表约束可以在表的一个或多个字段上定义：

CREATE TABLE films (
    code        char(5),
    title       varchar(40),
    did         integer,
    date_prod   date,
    kind        varchar(10),
    len         interval hour to minute,
    CONSTRAINT production UNIQUE(date_prod)
);

 定义一个检查列约束：

CREATE TABLE distributors (
    did     integer CHECK (did > 100),
    name    varchar(40)
);

 定义一个检查表约束：

CREATE TABLE distributors (
    did     integer,
    name    varchar(40)
    CONSTRAINT con1 CHECK (did > 100 AND name <> '''')
);

 为表 films 定义一个主键表约束。 主键表约束可以定义在表上的一个或多个字段。

CREATE TABLE films (
    code        char(5),
    title       varchar(40),
    did         integer,
    date_prod   date,
    kind        varchar(10),
    len         interval hour to minute,
    CONSTRAINT code_title PRIMARY KEY(code,title)
);

 为表 distributors 定义一个主键约束。 下面两个例子是等效的，第一个例子使用了表约束语法， 第二个使用了列约束表示法。

CREATE TABLE distributors (
    did     integer,
    name    varchar(40),
    PRIMARY KEY(did)
);

CREATE TABLE distributors (
    did     integer PRIMARY KEY,
    name    varchar(40)
);

 下面这个例子给字段 name 赋予了一个文本常量缺省值， 并且将字段 did 的缺省值安排为通过选择序列对象的下一个值生成。 modtime 的缺省值将是该行插入的时候的时间。

CREATE TABLE distributors (
    name      varchar(40) DEFAULT ''Luso Films'',
    did       integer DEFAULT nextval(''distributors_serial''),
    modtime   timestamp DEFAULT current_timestamp
);

 在表 distributors 上定义两个 NOT NULL 列约束，其中之一明确给出了名字：

CREATE TABLE distributors (
    did     integer CONSTRAINT no_null NOT NULL,
    name    varchar(40) NOT NULL
);

 为 name 字段定义一个唯一约束：

CREATE TABLE distributors (
    did     integer,
    name    varchar(40) UNIQUE
);

 上面的和下面这样作为一个表约束声明是一样的：

CREATE TABLE distributors (
    did     integer,
    name    varchar(40),
    UNIQUE(name)
);

COMPATIBILITY 兼容性

CREATE TABLE 遵循 SQL92 和 SQL99 的一个子集，一些例外情况在下面列出。

TEMPORARY TABLES 临时表

 尽管 CREATE TEMPORARY TABLE 的语法和 SQL 标准的类似， 但是效果是不同的。在标准里，临时表只是定义一次并且自动存在（从空内容开始）于任何需要它们的会话中。 PostgreSQL 要求每个会话为它们使用的每个临时表发出它们自己的 CREATE TEMPORARY TABLE 命令。 这样就允许不同的会话将相同的临时表名字用于不同的目的，而标准的实现方法则把一个临时表名字约束为具有相同的表结构。

 标准定义的临时表的行为被广泛地忽略了。PostgreSQL  在这方面上地行为类似于许多其它 SQL 数据库

 标准中在全局和局部地临时表之间的区别在 PostgreSQL  里不存在，因为这种区别取决于模块的概念，而 PostgreSQL  没有这个概念。出于兼容考虑，PostgreSQL 将接受临时表声明中的 GLOBAL 和 LOCAL 关键字， 但是他们没有作用。

 临时表的 ON COMMIT 子句也类似于 SQL 标准， 但是有些区别。如果忽略了 ON COMMIT 子句，SQL 声明缺省的行为是 ON COMMIT DELETE ROWS。 但是 PostgreSQL 里的缺省行为是 ON COMMIT PRESERVE ROWS。 在 SQL 里不存在 ON COMMIT DROP。

COLUMN CHECK CONSTRAINTS 字段检查约束

 SQL 标准说 CHECK 字段约束只能引用他们施用的字段； 只有 CHECK 表约束才能引用多个字段。PostgreSQL 并不强制这个限制；它把字段和表约束看作相同的东西。

NULL ``CONSTRAINT'''' NULL约束

NULL "约束"（实际上不是约束）是 PostgreSQL 对 SQL 标准的扩展， 包括它是为了和其它一些数据库系统兼容（以及为了和 NOT NULL 约束对称）。因为它是任何字段的缺省，所以它的出现只是噪音而已。

INHERITANCE 继承

 通过 INHERITS 子句的多重继承是 PostgreSQL 语言的扩展。 SQL99（但不包括 SQL92）使用不同的语法和语义定义了单继承。 SQL99 风格的继承还没有在 PostgreSQL 中实现。

OBJECT IDS 对象ID

PostgreSQL 的 OID 的概念不标准。

ZERO-COLUMN TABLES 零行表

PostgreSQL 允许创建没有字段的表 （比如，CREATE TABLE foo();）。这是对 SQL 标准的扩展， 标准不允许存在零字段表。零字段表本身没什么用，但是禁止他们会给 ALTER TABLE DROP COLUMN带来很奇怪的情况，所以，这个时候忽视标准的限制好想很清楚。 

今天关于htable recreate的介绍到此结束，谢谢您的阅读，有关Can''t create table ''table_name''; table exists - 如何解决MySQL报错：无法创建表，表已存在、com.facebook.presto.sql.tree.CreateTableAsSelect的实例源码、create table、CREATE TABLE - 定义一个新表等更多相关知识的信息可以在本站进行查询。