Tenho um banco de dados com 104 triggers, existe alguma forma de deletar todos os triggers com um único comando de um único banco de dados chamado 'system_db_audits?
Eu fiz o seguinte procedimento armazenado:
ALTER PROCEDURE usp_actorBirthdays (@nameString nvarchar(100), @actorgender nvarchar(100))
AS
SELECT ActorDOB, ActorName FROM tblActor
WHERE ActorName LIKE '%' + @nameString + '%'
AND ActorGender = @actorgender
Agora, eu tentei fazer algo assim. Talvez eu esteja fazendo isso errado, mas quero ter certeza de que tal procedimento pode impedir qualquer SQL Injection:
EXEC usp_actorBirthdays 'Tom', 'Male; DROP TABLE tblActor'
A imagem abaixo mostra o SQL acima sendo executado no SSMS e os resultados sendo exibidos corretamente ao invés de um erro:
A propósito, adicionei essa parte após o ponto e vírgula depois que a consulta foi executada. Depois executei novamente, mas quando verifiquei se a tabela tblActor existe ou não, ela ainda estava lá. Estou fazendo algo errado? Ou isso é realmente à prova de injeção? Acho que o que estou tentando perguntar aqui também é que um procedimento armazenado como este é seguro? Obrigada.
Ao clicar com o botão direito do mouse em uma tabela e selecionar "selecionar as 1000 principais linhas", recebo este erro:
Existe alguma solução alternativa, além da atualização óbvia para o SQL Server 2014?
No PostgreSQL 9.2.2 (Windows 32 bits), tenho um pg_restorecomando que resulta sistematicamente em avisos de log sobre a frequência do ponto de verificação, por exemplo:
LOG: checkpoints are occurring too frequently (17 seconds apart)
HINT: Consider increasing the configuration parameter "checkpoint_segments".
O banco de dados tem cerca de 3,3 Gb de tamanho com 112 tabelas/160 exibições e restaura em cerca de 14 minutos.
É normal que isso ocorra durante um pg_restore?
tenho uma tabela:
CREATE TABLE [dbo].[Realty](
[Id] [int] IDENTITY(1,1) NOT NULL,
[RankingBonus] [int] NOT NULL,
[Ranking] AS ([Id]+[RankingBonus]) PERSISTED NOT NULL
....
)
E uma vista:
CREATE View [dbo].[FilteredRealty] AS
SELECT
realty.Id as realtyId,
...
COALESCE(realty.Wgs84X, ruian_cobce.Wgs84X, ruian_obec.Wgs84X) as Wgs84X,
COALESCE(realty.Wgs84Y, ruian_cobce.Wgs84Y, ruian_obec.Wgs84Y) as Wgs84Y,
realty.Ranking,
...
FROM realty
JOIN Category ON realty.CategoryId = Category.Id
LEFT JOIN ruian_cobce ON realty.cobceId = ruian_cobce.cobce_kod
LEFT JOIN ruian_obec ON realty.obecId = ruian_obec.obec_kod
LEFT JOIN okres ON realty.okresId = okres.okres_kod
LEFT JOIN ExternFile ON realty.Id = ExternFile.ForeignId AND ExternFile.IsMain = 1
AND ExternFile.ForeignTable = 5
INNER JOIN Person ON realty.OwnerId = Person.Id
WHERE Person.ConfirmStatus = 1
Eu tenho um modelo dbml em C# (LinqToSQL) com a exibição FilteredRealty nele. O campo [Ranking] é reconhecido como um int anulável e, portanto, tenho que corrigir o tipo no código gerado toda vez que altero algo no banco de dados. Isso é muito frustrante para mim e muito trabalho manual.
Não há agregações usadas no FilteredRealty (em relação a esta questão relacionada ).
Por que a coluna Classificação da exibição é considerada anulável se Realty.Ranking não for anulável?
Tenho 4 tabelas relacionadas assim (é um exemplo):
Company:
ID
Name
CNPJ
Department:
ID
Name
Code
ID_Company
Classification:
ID
Name
Code
ID_Company
Workers:
Id
Name
Code
ID_Classification
ID_Department
Suponha que eu tenha um classificationcom id = 20, id_company = 1. E uma departmentque tem id_company = 2(que representa outra empresa).
Isso permitirá a criação de um trabalhador que seja de duas empresas, pois a classificação e o departamento estão vinculados à empresa separadamente. Não quero que isso aconteça, então acho que tenho um problema com meus relacionamentos e não sei como resolver.
Sei que isso já foi perguntado aqui e aqui , mas tenho a mesma ideia com uma possível implementação diferente e preciso de ajuda.
Inicialmente eu tinha minha blogstoriestabela com essa estrutura:
| Column | Type | Description |
|-----------|-------------|------------------------------------------------|
| uid | varchar(15) | 15 characters unique generated id |
| title | varchar(60) | story title |
| content | longtext | story content |
| author | varchar(10) | id of the user that originally wrote the story |
| timestamp | int | integer generated with microtime() |
Depois que decidi que queria implementar algum sistema de versionamento para cada história do blog, a primeira coisa que me veio à cabeça foi criar uma tabela diferente para guardar as edições ; depois disso, pensei que poderia modificar a tabela existente para conter versões em vez de edições . Esta é a estrutura que me veio à mente:
| Column | Type | Description |
|------------ |------------- |------------------------------------------------ |
| story_id | varchar(15) | 15 characters unique generated id |
| version_id | varchar(5) | 5 characters unique generated id |
| editor_id | varchar(10) | id of the user that commited |
| author_id | varchar(10) | id of the user that originally wrote the story |
| timestamp | int | integer generated with microtime() |
| title | varchar(60) | current story title |
| content | longtext | current story text |
| coverimg | varchar(20) | cover image name |
As razões pelas quais eu vim aqui:
- O
uidcampo da tabela inicial era UNIQUE na tabela. Agora, ostory_idnão é mais exclusivo. Como devo lidar com isso? (Achei que poderia abordarstory_id = xe encontrar a versão mais recente, mas isso parece consumir muitos recursos, então, por favor, dê seu conselho) author_ido valor do campo está se repetindo em cada linha da tabela. Onde e como devo guardá-lo?
Editar
O processo de geração de códigos únicos está na CreateUniqueCodefunção:
trait UIDFactory {
public function CryptoRand(int $min, int $max): int {
$range = $max - $min;
if ($range < 1) return $min;
$log = ceil(log($range, 2));
$bytes = (int) ($log / 8) + 1;
$bits = (int) $log + 1;
$filter = (int) (1 << $bits) - 1;
do {
$rnd = hexdec(bin2hex(openssl_random_pseudo_bytes($bytes)));
$rnd = $rnd & $filter;
} while ($rnd >= $range);
return $min + $rnd;
}
public function CreateUID(int $length): string {
$token = "";
$codeAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
$codeAlphabet.= "abcdefghijklmnopqrstuvwxyz";
$codeAlphabet.= "0123456789";
$max = strlen($codeAlphabet) - 1;
for ($i=0; $i < $length; $i++) {
$token .= $codeAlphabet[$this->CryptoRand(0, $max)];
}
return $token;
}
}
O código está escrito em Hack e foi originalmente escrito em PHP por @Scott em sua resposta .
Os campos author_ide editor_id podem ser diferentes, pois existem usuários com permissões suficientes para editar as histórias de qualquer pessoa.
Eu estou querendo saber por que, para função de valor escalar, que eu tenho que conceder ao usuário para executar em vez de apenas um select?
enquanto isso, uma função com valor de tabela funciona bem com apenas permissão ou db_datareaderassociação de seleção.
para ser mais claro aqui está o meu exemplo: Eu preciso de um usuário que tenha permissão somente leitura para o banco de dados. então eu criei um usuário chamado testUsere dei a ele uma db_datareaderassociação. então eu criei uma função com valor de tabela chamada fn_InlineTable. E tudo é ótimo. testUserexecuta esse SQL o dia todo
select * from dbo.fn_InlineTable
então eu preciso de uma função escalar, então criei uma função escalar chamada fn_ScalarTest.
testUsernão pode executar este SQL
Select dbo.fn_ScalarTest(1)
Bem compreensivelmente: é porque eu não dei permissão "testUser" para executar fn_ScalarTest.
Minha pergunta é: com base neste link https://stackoverflow.com/questions/6150888/insert-update-delete-with-function-in-sql-server , que diz que FUNCTIONnão pode ser usado para executar ações que modificam o estado do banco de dados . Então, por que não permitir que uma função escalar seja usada com a mesma permissão "SELECT" em vez de permissão de execução?
Espero que minha pergunta faça sentido. Obrigada.
Eu configurei o agrupamento de banco de dados para Latin1_General_BIN, para fazer comparações de strings com distinção entre maiúsculas e minúsculas. Isso terá impacto no desempenho? Isso terá algum impacto nas operações DML ou DDL no banco de dados? O banco de dados já existe com tabelas nele.
Estou usando o PostgreSQL 9.3 no RDS. De vez em quando, executo uma operação VACUUM FULL no banco de dados. No entanto, essa operação pode demorar bastante e bloquear outras tabelas, portanto, pode surgir a necessidade de interromper a operação.
É seguro interromper uma VACUUM FULLoperação que demora muito?