update werkt niet bij een bepaald aantal tabelrijen

Hebben we het echt over 130 records/items/rijen of over kolommen?
Een tabel met 130 kolommen klinkt mij namelijk in de oren als een zeer complexe datastructuur die je liever wilt normaliseren, en waar uiteindelijk je op zou kunnen vastlopen door de complexiteit.

Of heb je het echt over records? Ik kan me niet indenken dat 130 records dan een bottleneck kan vormen. Een tabel kan met gemak miljoenen records aan.

De vraag is: Wat gebeurt er precies, en wat meldt de foutafhandeling bijvoorbeeld met [php]mysqli_error[/php]? Ga dat eerst eens onderzoeken.

We hebben het over 130 records in een tabel van ongeveer 10 kolommen (datum, tijd en kleine teksten e.d.).

Ik ga met die mysqli_error aan de slag. Bedankt.

Is toevallig het auto-increment id te klein? Daarbij, als dit geen unsigned integer is gooi je sowieso al ongeveer de helft van de beschikbare nummers weg omdat auto-increment id's niet negatief kunnen zijn.

EDIT: hm, hoe ziet de structuur er uit, en wat gebeurt er tijdens het updaten?

Het ID heb ik 5 cijfers gemaakt en unsigned toegevoegd. Geen resultaat. Het formulier dat verstuurd wordt is opgebouwd uit de tabelrecords. Voor iedere regel is een checked opgenomen. Wanneer deze is aangevinkt kan dat record direct in de tabel worden aangepast. Door de verzendknop wordt het totaal verstuurd en wordt de querie uitgevoerd. Dit werkt prima tot kennelijk een beperkt aantal records.

Ik weet niet of dat kan, maar ik heb de indruk dat het formulier te groot wordt om te verwerken. Ik heb mysqli_error ingezet om een reactie te krijgen, maar dat gebeurt niet. Kennelijk wordt heel de verbinding/querie niet bereikt.

Ziet je FORM er zo uit? Maar dan 130 regels ipv 5.

http://adoptive.2kool4u.net/members/

Zou betekenen dat je complete DB in een $_POST wordt verstuurd.

Wat zie je, uit nieuwsgierigheid, als je een print_r($_POST) doet?

Dat klopt. Je voorbeeld is vergelijkbaar. Met de print_r($_POST) wordt de hele Dbase als array weergegeven

Je moet dan door die array gaan en elk record updaten.

Hier de code uit het voorbeeld (alleen de vinkjes worden bewaard) :

if( isset( $_POST['Submit'] ) ) {

	$count         = count( $_POST['id'] );
	$count_present = count( $_POST['present'] );

	for( $i = 0 ; $i < $count ; $i++ ){
		$id         = $db->real_escape_string( $_POST['id'][$i] );
		$full_name  = $db->real_escape_string( $_POST['full_name'][$i] );
		$email      = $db->real_escape_string( $_POST['email'][$i] );
		$age        = $db->real_escape_string( $_POST['age'][$i] );
		$present    = 0;

		for( $y = 0 ; $y < $count_present ; $y++ ) {
			if ( $_POST["present"][$y] == $id ) {
				$present = 1;
				break;
			}
		}

// in demo wordt alleen present bewaard. andere velden niet
		$query = "
		UPDATE
			$tbl_name
		SET
			present   = '" . $present   . "'
		WHERE
			id = '" . $id . "'";

		$db->query($query);
	}

}

[size=xsmall]Toevoeging op 29/03/2019 17:17:04:[/size]

In het voorbeeld wordt elk record apart geupdate.

Was toen niet bekend met "insert on duplucate update". Zou dat nu wel gebruiken.

http://www.mysqltutorial.org/mysql-insert-or-update-on-duplicate-key-update/

Je moet dan de $_POST gaan bewerken in een query zoal dit :

$query = "
INSERT INTO
	students
		(id, name, class, social, science, math)
	VALUES
		(2,  'Max Ruin',    'Three', 86, 57, 86),
		(3,  'Arnold',      'Three', 56, 41, 76),
		(4,  'Krish Star',  'Four',  62, 52, 72),
		(5,  'John Mike',   'Four',  62, 82, 92),
		(6,  'Alex John',   'Four',  58, 93, 83),
		(7,  'My John Rob', 'Fifth', 79, 64, 74),
		(8,  'Asruid',      'Five',  89, 84, 94),
		(9,  'Tes Qry',     'Six',   77, 61, 71),
		(10, 'Big John',    'Four',  56, 44, 56),
		(11, 'New Name',    'Five',  75, 78, 52) 
ON DUPLICATE KEY UPDATE
	social  = values( social ),
	science = values( science),
	math    = values( math   );
";

Ik gebruik het af en toe om een duizend records per keer toe te voegen of bij te werken.

Maar als je 130 rijen invoegt, en je vergeet ergens een vinkje, dan mis je weer een update. Zelf zou ik een hele waslijst aan records opsplitsen in losse pagina's d.m.v. een paginate-script.

Zelf heb ik voor een dergelijk script de vinkjes afgeschaft en per stuk gekeken of er gepost is. Of nog mooier om de array's van je $_POST en al je items in je database met elkaar te vergelijken. En wijzigingen enkel door te voeren.
<?php
function array_diff_assoc_recursive($array1, $array2) {
foreach ($array1 as $key => $value) {
if (is_array($value)) {
if (!isset($array2[$key])) {
$difference[$key] = $value;
} elseif (!is_array($array2[$key])) {
$difference[$key] = $value;
} else {
$new_diff = array_diff_assoc_recursive($value, $array2[$key]);
if ($new_diff != FALSE) {
$difference[$key] = $new_diff;
}
}
} elseif (!isset($array2[$key]) || $array2[$key] != $value) {
$difference[$key] = $value;
}
}
return !isset($difference) ? 0 : $difference;
}

// loop de arrays recursief door en toon de verschillen.
$diff = array_diff_assoc_recursive($_POST['items'], $data);

// toon je de array
echo "<pre>".print_r($diff,1)."</pre>";
?>

Uhm. 130 records x 10 velden. Qua POST data zou dat geen enkel probleem moeten vormen? Ik zou dan eerder denken aan een andere bottleneck zoals bijvoorbeeld PHP-instellingen als max_input_vars of post_max_size ofzo. Of je code moet wel heel erg brak in elkaar zitten.

Maar het blijft koffiedik kijken zonder concrete code.

Volgens mij staat dit standaard in PHP op 1000. Dus dan kom je uit op 1300 velden...
Dan kan het inderdaad een probleem vormen.

Daarom was 'pagination' juist handig, herinner ik me net na jouw post.
Dan beperk je het tot 25*10 velden, of je moet je max_input_vars verhogen, maar gebruikersvriendelijk gezien is opsplitsen over meerdere pagina's makkelijker in gebruik.