DaoOne
3.30
DaoOne . É um wrapper simples para Mysqli
Esta biblioteca é o mais rápida possível. A maioria das operações são gerenciamentos simples de strings/matrizes.
Observação: esta versão foi movida para https://github.com/EFTEC/PdoOne
PdoOne faz o mesmo trabalho, mas funciona com a biblioteca PDO (em vez do MySQLi). No momento o PdoOne funciona com Mysqli e SqlSrv mas possui muitos outros recursos que não estarão presentes no DaoOne
Instalar via compositor
compositor requer eftec/pdoone
Esta biblioteca pode funcionar em conjunto com eftec/ DaoOne .
Mude a classe, em vez de usar eftec/ DaoOne -> eftec/pdoone
Exemplo:
Antes:
/** @var eftec DaoOne $db */
$ db = null ;Depois:
/** @var eftecPdoOne $db */
$ db = null ;Antes:
$ db = new DaoOne ( ' 127.0.0.1 ' , ' root ' , ' abc.123 ' , ' sakila ' );Depois:
$ db = new DaoOne ( ' mysql ' , ' 127.0.0.1 ' , ' root ' , ' abc.123 ' , ' sakila ' ); // check 'mysql' Se usarmos DaoOne ::runGen(false), devemos verificar o resultado. runGen ( DaoOne ) retorna um objeto mysqli_result. runGen (PdoOne) retorna um objeto pdostatement.
Antes:
$ result = $ db -> runGen ( false ); // it returns a mysqli_result
$ result -> fetch_assoc ();
$ result -> free_result ();Depois:
$ result = $ db -> runGen ( false ); // it returns a pdostatement
$ result -> fetch ( PDO :: FETCH_ASSOC );
$ result = null ;Vire isso
$stmt->bind_param("s", $_POST['name']);
$stmt->execute();
$result = $stmt->get_result();
if($result->num_rows === 0) exit('No rows');
while($row = $result->fetch_assoc()) {
$ids[] = $row['id'];
$names[] = $row['name'];
$ages[] = $row['age'];
}
var_export($ages);
$stmt->close();
nisso
$products=$dao
->select("*")
->from("myTable")
->where("name = ?",[$_POST['name']])
->toList();
Adicione ao compositor.json o próximo requisito e atualize o compositor.
{
"require" : {
"eftec/ DaoOne " : " ^3.15 "
}
}ou instale-o via cli usando
compositor requer eftec/ DaoOne
Basta baixar o arquivo lib/ DaoOne .php e salvá-lo em uma pasta.
$ dao = new DaoOne ( " 127.0.0.1 " , " root " , " abc.123 " , " sakila " , "" );
$ dao -> connect ();onde
$ sql = " CREATE TABLE `product` (
`idproduct` INT NOT NULL AUTO_INCREMENT,
`name` VARCHAR(45) NULL,
PRIMARY KEY (`idproduct`)); " ;
$ dao -> runRawQuery ( $ sql ); $ sql = " insert into `product`(name) values(?) " ;
$ stmt = $ dao -> prepare ( $ sql );
$ productName = " Cocacola " ;
$ stmt -> bind_param ( " s " , $ productName ); // s stand for string. Also i =integer, d = double and b=blob
$ dao -> runQuery ( $ stmt );nota: você também pode inserir usando uma cadeia processual insert($table,$schema,[$values])
$ dao -> runRawQuery ( ' insert into `product` (name) values(?) '
, array ( ' s ' , ' cocacola ' ));Ele retorna um mysqli_statement.
$ sql = " select * from `product` order by name " ;
$ stmt = $ dao -> prepare ( $ sql );
$ dao -> runQuery ( $ stmt );
$ rows = $ stmt -> get_result ();
while ( $ row = $ rows -> fetch_assoc ()) {
var_dump ( $ row );
}
Esta declaração deve ser processada manualmente.
Ele retorna uma matriz associativa.
$ sql = " select * from `product` order by name " ;
$ stmt = $ dao -> prepare ( $ sql );
$ dao -> runQuery ( $ stmt );
$ rows = $ stmt -> get_result ();
$ allRows = $ rows -> fetch_all ( MYSQLI_ASSOC );
var_dump ( $ allRows ); try {
$ sql = " insert into `product`(name) values(?) " ;
$ dao -> startTransaction ();
$ stmt = $ dao -> prepare ( $ sql );
$ productName = " Fanta " ;
$ stmt -> bind_param ( " s " , $ productName );
$ dao -> runQuery ( $ stmt );
$ dao -> commit (); // transaction ok
} catch ( Exception $ e ) {
$ dao -> rollback ( false ); // error, transaction cancelled.
}Ele inicia uma transação
Ele confirma uma transação.
Ele reverte uma transação.
Se for verdadeiro (padrão), gerará um erro se ocorrer um erro. Se for falso, a execução continua
É verdade se o banco de dados estiver conectado, caso contrário, é falso.
Você também pode criar uma consulta processual.
Exemplo:
$ results = $ dao -> select ( " * " )-> from ( " producttype " )
-> where ( ' name=? ' , [ ' s ' , ' Cocacola ' ])
-> where ( ' idproducttype=? ' , [ ' i ' , 1 ])
-> toList (); Gera um comando de seleção.
$ results = $ dao -> select ( " col1,col2 " )->. . .Gera a consulta: select col1,col2 ....
$ results = $ dao -> select ( " select * from table " )->. . .Gera a consulta: select * from table ....
Gera um comando de seleção.
$ results = $ dao -> select ( " col1,col2 " )-> distinct (). . .Gera a consulta: selecione distinto col1,col2 ....
Nota: ->distinct('unique') retorna select unique ..
Gera um comando from.
$ results = $ dao -> select ( " * " )-> from ( ' table ' ). . .Gera a consulta: selecione * da tabela
$tables pode ser uma única tabela ou uma construção sql. Por exemplo, o próximo comando é válido:
$ results = $ dao -> select ( " * " )-> from ( ' table t1 inner join t2 on t1.c1=t2.c2 ' ). . .Gera um comando where.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=1 ' ). . .Gera a consulta: selecione * da tabela onde p1=1
Nota: ArrayParameters é um array como segue: tipo, valor.
Onde o tipo é i=inteiro, d=duplo, s=string ou b=blob. Em caso de dúvida, use "s"
Exemplo de arrayParameters:
['i',1 ,'s','olá' ,'d',20.3 ,'s','mundo']
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=? ' ,[ ' i ' , 1 ]). . .Gera a consulta: selecione * da tabela onde p1=?(1)
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=? and p2=? ' ,[ ' i ' , 1 , ' s ' , ' hello ' ]). . .Gera a consulta: selecione * da tabela onde p1=?(1) e p2=?('hello')
Observação. onde poderia ser aninhado.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=? ' ,[ ' i ' , 1 ])
-> where ( ' p2=? ' ,[ ' s ' , ' hello ' ]). . .Gera a consulta: selecione * da tabela onde p1=?(1) e p2=?('hello')
Você também pode usar:
$ results = $ dao -> select ( " * " )-> from ( " table " )
-> where ([ ' p1 ' => ' Coca-Cola ' , ' p2 ' => 1 ])
-> toList ();Gera a consulta: selecione * da tabela onde p1=?(Coca-Cola) e p2=?(1)
Gera um comando de pedido.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> order ( ' p1 desc ' ). . .Gera a consulta: select * from table order by p1 desc
Gera um comando de grupo.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> group ( ' p1 ' ). . .Gera a consulta: selecione * do grupo de tabelas por p1
Gera um comando de grupo.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> group ( ' p1 ' )
-> having ( ' p1>? ' , array ( ' i ' , 1 )). . .Gera a consulta: selecione * do grupo de tabelas por p1 tendo p1>?(1)
Nota: Tendo pode ser aninhado tendo()->tendo()
Nota: Tendo poderia ser sem parâmetros tendo('col>10')
Execute a consulta gerada.
Observe que se returnArray for verdadeiro, ele retornará um array associativo. se returnArray for falso então ele retorna um mysqli_result
Nota: Ele redefine os parâmetros atuais (como seleção atual, de, onde, etc.)
É uma macro do runGen. Ele retorna uma matriz associativa ou nula.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> toList ()É uma macro do runGen. Ele retorna um mysqli_result ou nulo.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> toResult ()É uma macro do runGen. Ele retorna a primeira linha (se houver, se não, retorna falso) como um array associativo.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> first ()É uma macro do runGen. Ele retorna a última linha (se houver, caso contrário, retorna falso) como um array associativo.
$ results = $ dao -> select ( " * " )
-> from ( ' table ' )
-> last ()Às vezes é mais eficiente executar order() e first() porque last() lê todos os valores.
Ele retorna o comando sql.
$ sql = $ dao -> select ( " * " )
-> from ( ' table ' )
-> sqlGen ();
echo $ sql ; // returns select * from table
$ results = $ dao -> toList (); // executes the queryNota: isso não redefine a consulta.
Existem quatro maneiras de executar cada comando.
Digamos que queremos adicionar um número inteiro na coluna col1 com o valor 20
Esquema e valores usando uma lista de valores : onde o primeiro valor é a coluna, o segundo é o tipo de valor (i=inteiro,d=duplo,s=string,b=blob) e o segundo array contém os valores.
$ dao -> insert ( " table "
,[ ' col1 ' , ' i ' ]
,[ 20 ]);Esquema e valores na mesma lista : onde o primeiro valor é a coluna, o segundo é o tipo de valor (i=inteiro,d=duplo,s=string,b=blob) e o terceiro é o valor.
$ dao -> insert ( " table "
,[ ' col1 ' , ' i ' , 20 ]);Esquema e valores usando duas matrizes associativas :
$ dao -> insert ( " table "
,[ ' col1 ' => ' i ' ]
,[ ' col1 ' => 20 ]);Esquema e valores usando uma única matriz associativa : o tipo é calculado automaticamente.
$ dao -> insert ( " table "
,[ ' col1 ' => 20 ]);Gera um comando de inserção.
$ dao -> insert ( " producttype "
,[ ' idproducttype ' , ' i ' , ' name ' , ' s ' , ' type ' , ' i ' ]
,[ 1 , ' cocacola ' , 1 ]);Usando cadeia aninhada (matriz única)
$ dao -> from ( " producttype " )
-> set ([ ' idproducttype ' , ' i ' , 0 , ' name ' , ' s ' , ' Pepsi ' , ' type ' , ' i ' , 1 ])
-> insert ();Usando conjunto múltiplo de cadeia aninhada
$ dao -> from ( " producttype " )
-> set ( " idproducttype=? " ,[ ' i ' , 101 ])
-> set ( ' name=? ' ,[ ' s ' , ' Pepsi ' ])
-> set ( ' type=? ' ,[ ' i ' , 1 ])
-> insert ();ou (o tipo é definido, se possível, automaticamente pelo MySql)
$ dao -> from ( " producttype " )
-> set ( " idproducttype=? " ,[ ' i ' , 101 ])
-> set ( ' name=? ' , ' Pepsi ' )
-> set ( ' type=? ' , 1 )
-> insert ();Usando conjunto declarativo de cadeia aninhada
$ dao -> from ( " producttype " )
-> set ( ' (idproducttype,name,type) values (?,?,?) ' ,[ ' i ' , 100 , ' s ' , ' Pepsi ' , ' i ' , 1 ])
-> insert ();Gera a consulta: insira em producttype(idproducttype,name,type) valores(?,?,?) ....
Gera um comando de inserção.
$ dao -> update ( " producttype "
,[ ' name ' , ' s ' , ' type ' , ' i ' ] //set
,[ 6 , ' Captain-Crunch ' , 2 ] //set
,[ ' idproducttype ' , ' i ' ] // where
,[ 6 ]); // where $ dao -> update ( " producttype "
,[ ' name ' => ' Captain-Crunch ' , ' type ' => 2 ] // set
,[ ' idproducttype ' => 6 ]); // where $ dao -> from ( " producttype " )
-> set ( " name=? " ,[ ' s ' , ' Captain-Crunch ' ]) //set
-> set ( " type=? " ,[ ' i ' , 6 ]) //set
-> where ( ' idproducttype=? ' ,[ ' i ' , 6 ]) // where
-> update (); // updateou
$ dao -> from ( " producttype " )
-> set ( " name=? " , ' Captain-Crunch ' ) //set
-> set ( " type=? " , 6 ) //set
-> where ( ' idproducttype=? ' ,[ ' i ' , 6 ]) // where
-> update (); // updateGera a consulta: update producttype set
name=?,type=? ondeidproducttype=? ....
Gera um comando de exclusão.
$ dao -> delete ( " producttype "
,[ ' idproducttype ' , ' i ' ] // where
,[ 7 ]); // where $ dao -> delete ( " producttype "
,[ ' idproducttype ' => 7 ]); // whereGera a consulta: delete from producttype where
idproducttype=? ....
Você também pode excluir por meio de uma cadeia de construtores DQL.
$ dao -> from ( " producttype " )
-> where ( ' idproducttype=? ' ,[ ' i ' , 7 ]) // where
-> delete (); $ dao -> from ( " producttype " )
-> where ([ ' idproducttype ' => 7 ]) // where
-> delete (); Gera a consulta: delete from producttype where
idproducttype=? ....
A sequência é uma alternativa ao campo AUTO_NUMERIC. Ele usa uma tabela para gerar um ID exclusivo.
A sequência utilizada é baseada no Snowflake do Twitter e é gerada com base no tempo (com microssegundos), Node Id e uma sequência. Isso gera um valor LONG (int 64) que é único
$dao->nodeId=1; // optional
$dao->tableSequence='snowflake'; // optional
$dao->createSequence(); // it creates a table called snowflake and a function called next_snowflake()
$dao->getSequence() // string(19) "3639032938181434317"
$dao->getSequence(true) // returns a sequence by flipping some values.
$dao->getSequencePHP([unpredictable=false]) Retorna uma sequência sem usar uma tabela. Esta sequência é mais eficiente que $dao->getSequence mas usa um valor aleatório para lidar com colisões.
Se upredictable for verdadeiro então ele retorna um número imprevisível (ele inverte alguns dígitos)
$dao->getSequencePHP() // string(19) "3639032938181434317"
$dao->getSequencePHP(true) // string(19) "1739032938181434311"
