Create temporary table
@param name string temporary table name
@param source_table string source table name
@param which_connection see method close
@return String separator
197197
public function temporaryTable($name, $source_table, $which_connection='')
    {
        $which_connection = $which_connection === '' ? $this->default_db : $which_connection;
        $adapter = $this->getAdapter($this->connectionType($which_connection));
        $query = $adapter->temporaryTable($name, $source_table);
        $created = $this->query($query, $which_connection);
        return $created ? $name : false;
    }
638006
public static function Create ($table_name, array $values = [], array $options = []) {
		return static::GetConnection($options)->create($table_name, $values, $options);
	}
977630
def table(self, name):
        
        qualified_name = self._qualify(name)
        return self.client.table(qualified_name, self.name)
1069682
private function createDatabase(
        OutputInterface $output,
        Connection $tmpConnection,
        string $name,
        bool $shouldNotCreateDatabase
    ): int {
        try {
            if ($shouldNotCreateDatabase) {
                $output->writeln(sprintf('<info>Database <comment>%s</comment> already exists.</info>', $name));
            } else {
                $tmpConnection->getSchemaManager()->createDatabase($name);
                $output->writeln(sprintf('<info>Created database <comment>%s</comment>', $name));
            }

            return 0;
        } catch (\Exception $e) {
            $output->writeln(sprintf('<error>Could not create database <comment>%s</comment></error>', $name));
            $output->writeln(sprintf('<error>%s</error>', $e->getMessage()));

            return 1;
        }
    }
718170
public function clearTableCache($which_connection='')
    {
        if ($which_connection == '') {
            $which_connection=$this->default_db;
        }
        $this->structure_cache[$which_connection] = array();

        return true;
    }
194730
public function tableExists($table_name,$which_connection='')
    {
        /**
          Check whether the definition is in cache
        */
        if (isset($this->structure_cache[$which_connection]) && isset($this->structure_cache[$which_connection][$table_name])) {
            return true;
        }

        $conn = $this->getNamedConnection($which_connection);
        if (!is_object($conn)) {
            return false;
        }
        $cols = $conn->MetaColumns($table_name);
        if ($cols === false) {
            return false;
        }

        return true;
    }
417680
private Metadata createMetadata(String tableName) {
    Metadata metadata = new Metadata();
    if (tableName != null) {
      metadata.put(GRPC_RESOURCE_PREFIX_KEY, tableName);
    }
    return metadata;
  }
127408
def create_table(name=str('_Table'), base=Table, options=None):
    
    try:
        base = tuple(base)
    except TypeError:
        # Then assume that what we have is a single class, so make it
        # into a 1-tuple.
        base = (base,)

    return TableMeta(name, base, options or {})
875966
public function createTable($name, Array $columns, $safe_create = false)
	{
		if( (! $safe_create) || ($safe_create && ! Schema::connection($this->connection)->hasTable('users')) )
		{
			// dtop table if exists
			if (Schema::connection($this->connection)->hasTable($name))
			{
				Schema::connection($this->connection)->drop($name);
			}
			
			Schema::connection($this->connection)->create($name, function($table) use ($columns)
			{
				foreach($columns as $name => $type)
				{
		    		$table->$type($name);
		    	}
			});
		}
	}
309074
def create_table(dbcon, name, columns):
    
    try:
        colString = ", ".join(["{} {}".format(colName, colType) for colName, colType in columns])
        dbcon.execute("CREATE TABLE '{name}'({args})".format(name=name, args=colString))
        return True
    except sqlite3.OperationalError as e:
        return False
1233805
def get_table(self, table_name, primary_id=None, primary_type=None):
        
        return self.create_table(table_name, primary_id, primary_type)
1042527
private TableDDL createTableDDL(String tableName) {
        TableMetadata tableMetadata = _keyspace.getKeyspaceMetadata().getTable(tableName);
        String rowKeyColumnName = tableMetadata.getPrimaryKey().get(0).getName();
        String timeSeriesColumnName = tableMetadata.getPrimaryKey().get(1).getName();
        String valueColumnName = tableMetadata.getColumns().get(2).getName();

        return new TableDDL(tableMetadata, rowKeyColumnName, timeSeriesColumnName, valueColumnName);
    }
84350
private void createLeaseTable(Connection conn) throws SQLException
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "createLeaseTable", new java.lang.Object[] { conn, this });

        Statement createTableStmt = null;
        PreparedStatement specStatement = null;

        try
        {
            createTableStmt = conn.createStatement();

            if (_isOracle)
            {
                String oracleTableString = oracleTablePreString + _leaseTableName + oracleTablePostString;
                if (tc.isDebugEnabled())
                    Tr.debug(tc, "Create Oracle Table using: " + oracleTableString);
                createTableStmt.executeUpdate(oracleTableString);
            }
            else
            {
                String db2TableString = db2TablePreString + _leaseTableName + db2TablePostString;
                if (tc.isDebugEnabled())
                    Tr.debug(tc, "Create DB2 Table using: " + db2TableString);
                createTableStmt.executeUpdate(db2TableString);
            }

        } finally
        {
            if (createTableStmt != null && !createTableStmt.isClosed())
            {
                createTableStmt.close();
            }
            if (specStatement != null && !specStatement.isClosed())
            {
                specStatement.close();
            }
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "createLeaseTable");
    }
47323
def create_table(self, name, *columns, **kwargs):
        
        targs = table_args(**kwargs)
        args, kwargs = targs[:-1], targs[-1]
        return Table(name, self.metadata, *columns, *args, **kwargs)
258391
public static <T> int createTable(ConnectionSource connectionSource, Class<T> dataClass) throws SQLException {
		Dao<T, ?> dao = DaoManager.createDao(connectionSource, dataClass);
		return doCreateTable(dao, false);
	}
957832
private T getOrCreate(String name) {
        T constant = constants.get(name);
        if (constant == null) {
            final T tempConstant = newConstant(nextId(), name);
            constant = constants.putIfAbsent(name, tempConstant);
            if (constant == null) {
                return tempConstant;
            }
        }

        return constant;
    }
193423
protected NamedParameterJdbcTemplate namedParameterJdbcTemplate(Connection conn) {
        DataSource ds = new SingleConnectionDataSource(conn, true);
        return new NamedParameterJdbcTemplate(ds);
    }